Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/StatisticsUI/BUILD

@@ -0,0 +1,63 @@
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_library")
+
+swift_library(
+    name = "StatisticsUI",
+    module_name = "StatisticsUI",
+    srcs = glob([
+		"Sources/**/*.swift",
+    ]),
+    copts = [
+        "-warnings-as-errors",
+    ],
+    deps = [
+        "//submodules/SSignalKit/SwiftSignalKit",
+        "//submodules/AsyncDisplayKit",
+        "//submodules/Display",
+        "//submodules/ComponentFlow",
+        "//submodules/Postbox",
+        "//submodules/TelegramCore",
+        "//submodules/TelegramPresentationData",
+        "//submodules/TelegramUIPreferences",
+        "//submodules/AccountContext",
+        "//submodules/ItemListUI",
+        "//submodules/AvatarNode",
+        "//submodules/TelegramStringFormatting",
+        "//submodules/AlertUI",
+        "//submodules/PresentationDataUtils",
+        "//submodules/MergeLists",
+        "//submodules/PhotoResources",
+        "//submodules/GraphCore",
+        "//submodules/GraphUI",
+        "//submodules/AnimatedStickerNode",
+        "//submodules/TelegramAnimatedStickerNode",
+        "//submodules/ItemListPeerItem",
+        "//submodules/ItemListPeerActionItem",
+        "//submodules/ContextUI",
+        "//submodules/PremiumUI",
+        "//submodules/InviteLinksUI",
+        "//submodules/ShareController",
+        "//submodules/TextFormat",
+        "//submodules/TelegramUI/Components/Stories/AvatarStoryIndicatorComponent",
+        "//submodules/TelegramUI/Components/Stories/StoryContainerScreen",
+        "//submodules/TelegramUI/Components/Settings/BoostLevelIconComponent",
+        "//submodules/TelegramUI/Components/PlainButtonComponent",
+        "//submodules/TelegramUI/Components/EmojiTextAttachmentView",
+        "//submodules/Components/SheetComponent",
+        "//submodules/Components/BundleIconComponent",
+        "//submodules/Components/MultilineTextComponent",
+        "//submodules/Components/MultilineTextWithEntitiesComponent",
+        "//submodules/TelegramNotices",
+        "//submodules/UIKitRuntimeUtils",
+        "//submodules/PasswordSetupUI",
+        "//submodules/TelegramUI/Components/PeerManagement/OwnershipTransferController",
+        "//submodules/TelegramUI/Components/ListItemComponentAdaptor",
+        "//submodules/TelegramUI/Components/Stars/StarsWithdrawalScreen",
+        "//submodules/TelegramUI/Components/ButtonComponent",
+        "//submodules/TelegramUI/Components/ListActionItemComponent",
+        "//submodules/TelegramUI/Components/Stars/StarsAvatarComponent",
+        "//submodules/TelegramUI/Components/PremiumPeerShortcutComponent",
+    ],
+    visibility = [
+        "//visibility:public",
+    ],
+)

submodules/StatisticsUI/Sources/BackButton.swift

@@ -0,0 +1,268 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import ContextUI
+import TelegramPresentationData
+import Display
+
+enum PeerInfoHeaderNavigationButtonKey {
+    case back
+    case edit
+    case done
+    case cancel
+    case select
+    case selectionDone
+    case search
+    case editPhoto
+    case editVideo
+    case more
+    case qrCode
+    case moreToSearch
+    case postStory
+}
+
+final class PeerInfoHeaderNavigationButton: HighlightableButtonNode {
+    let containerNode: ContextControllerSourceNode
+    let contextSourceNode: ContextReferenceContentNode
+    private let textNode: ImmediateTextNode
+    private let iconNode: ASImageNode
+    private let backIconLayer: SimpleShapeLayer
+    private let backgroundNode: NavigationBackgroundNode
+    
+    private var key: PeerInfoHeaderNavigationButtonKey?
+    
+    private var contentsColor: UIColor = .white
+    private var canBeExpanded: Bool = false
+    
+    var action: ((ASDisplayNode, ContextGesture?) -> Void)?
+    
+    init() {
+        self.contextSourceNode = ContextReferenceContentNode()
+        self.containerNode = ContextControllerSourceNode()
+        self.containerNode.animateScale = false
+        
+        self.textNode = ImmediateTextNode()
+        
+        self.iconNode = ASImageNode()
+        self.iconNode.displaysAsynchronously = false
+        self.iconNode.displayWithoutProcessing = true
+        
+        self.backIconLayer = SimpleShapeLayer()
+        self.backIconLayer.lineWidth = 3.0
+        self.backIconLayer.lineCap = .round
+        self.backIconLayer.lineJoin = .round
+        self.backIconLayer.strokeColor = UIColor.white.cgColor
+        self.backIconLayer.fillColor = nil
+        self.backIconLayer.isHidden = true
+        self.backIconLayer.path = try? convertSvgPath("M10.5,2 L1.5,11 L10.5,20 ")
+        
+        self.backgroundNode = NavigationBackgroundNode(color: .clear, enableBlur: true)
+        
+        super.init(pointerStyle: .insetRectangle(-8.0, 2.0))
+        
+        self.isAccessibilityElement = true
+        self.accessibilityTraits = .button
+        
+        self.containerNode.addSubnode(self.contextSourceNode)
+        self.contextSourceNode.addSubnode(self.backgroundNode)
+        self.contextSourceNode.addSubnode(self.textNode)
+        self.contextSourceNode.addSubnode(self.iconNode)
+        self.contextSourceNode.layer.addSublayer(self.backIconLayer)
+
+        self.addSubnode(self.containerNode)
+        
+        self.containerNode.activated = { [weak self] gesture, _ in
+            guard let strongSelf = self else {
+                return
+            }
+            strongSelf.action?(strongSelf.contextSourceNode, gesture)
+        }
+        
+        self.addTarget(self, action: #selector(self.pressed), forControlEvents: .touchUpInside)
+    }
+    
+    @objc private func pressed() {
+        self.action?(self.contextSourceNode, nil)
+    }
+    
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        var boundingRect = self.bounds
+        if self.textNode.alpha != 0.0 {
+            boundingRect = boundingRect.union(self.textNode.frame)
+        }
+        boundingRect = boundingRect.insetBy(dx: -8.0, dy: -4.0)
+        if boundingRect.contains(point) {
+            return super.hitTest(self.bounds.center, with: event)
+        } else {
+            return nil
+        }
+    }
+    
+    func updateContentsColor(backgroundColor: UIColor, contentsColor: UIColor, canBeExpanded: Bool, transition: ContainedViewLayoutTransition) {
+        self.contentsColor = contentsColor
+        self.canBeExpanded = canBeExpanded
+        
+        self.backgroundNode.updateColor(color: backgroundColor, transition: transition)
+        
+        transition.updateTintColor(layer: self.textNode.layer, color: self.contentsColor)
+        transition.updateTintColor(layer: self.iconNode.layer, color: self.contentsColor)
+        transition.updateStrokeColor(layer: self.backIconLayer, strokeColor: self.contentsColor)
+        
+        switch self.key {
+        case .back:
+            transition.updateAlpha(layer: self.textNode.layer, alpha: canBeExpanded ? 1.0 : 0.0)
+            transition.updateTransformScale(node: self.textNode, scale: canBeExpanded ? 1.0 : 0.001)
+            
+            var iconTransform = CATransform3DIdentity
+            iconTransform = CATransform3DScale(iconTransform, canBeExpanded ? 1.0 : 0.8, canBeExpanded ? 1.0 : 0.8, 1.0)
+            iconTransform = CATransform3DTranslate(iconTransform, canBeExpanded ? -7.0 : 0.0, 0.0, 0.0)
+            transition.updateTransform(node: self.iconNode, transform: CATransform3DGetAffineTransform(iconTransform))
+            
+            transition.updateTransform(layer: self.backIconLayer, transform: CATransform3DGetAffineTransform(iconTransform))
+            transition.updateLineWidth(layer: self.backIconLayer, lineWidth: canBeExpanded ? 3.0 : 2.075)
+        default:
+            break
+        }
+    }
+    
+    func update(key: PeerInfoHeaderNavigationButtonKey, presentationData: PresentationData, height: CGFloat) -> CGSize {
+        let transition: ContainedViewLayoutTransition = .immediate
+        
+        var iconOffset = CGPoint()
+        switch key {
+        case .back:
+            iconOffset = CGPoint(x: -1.0, y: 0.0)
+        default:
+            break
+        }
+        
+        let textSize: CGSize
+        if self.key != key {
+            self.key = key
+            
+            let text: String
+            var accessibilityText: String
+            var icon: UIImage?
+            var isBold = false
+            var isGestureEnabled = false
+            switch key {
+            case .back:
+                text = presentationData.strings.Common_Back
+                accessibilityText = presentationData.strings.Common_Back
+                icon = NavigationBar.backArrowImage(color: .white)
+            case .edit:
+                text = presentationData.strings.Common_Edit
+                accessibilityText = text
+            case .cancel:
+                text = presentationData.strings.Common_Cancel
+                accessibilityText = text
+                isBold = false
+            case .done, .selectionDone:
+                text = presentationData.strings.Common_Done
+                accessibilityText = text
+                isBold = true
+            case .select:
+                text = presentationData.strings.Common_Select
+                accessibilityText = text
+            case .search:
+                text = ""
+                accessibilityText = presentationData.strings.Common_Search
+                icon = nil// PresentationResourcesRootController.navigationCompactSearchIcon(presentationData.theme)
+            case .editPhoto:
+                text = presentationData.strings.Settings_EditPhoto
+                accessibilityText = text
+            case .editVideo:
+                text = presentationData.strings.Settings_EditVideo
+                accessibilityText = text
+            case .more:
+                text = ""
+                accessibilityText = presentationData.strings.Common_More
+                icon = nil// PresentationResourcesRootController.navigationMoreCircledIcon(presentationData.theme)
+                isGestureEnabled = true
+            case .qrCode:
+                text = ""
+                accessibilityText = presentationData.strings.PeerInfo_QRCode_Title
+                icon = PresentationResourcesRootController.navigationQrCodeIcon(presentationData.theme)
+            case .moreToSearch:
+                text = ""
+                accessibilityText = ""
+            case .postStory:
+                text = ""
+                accessibilityText = presentationData.strings.Story_Privacy_PostStory
+                icon = PresentationResourcesRootController.navigationPostStoryIcon(presentationData.theme)
+            }
+            self.accessibilityLabel = accessibilityText
+            self.containerNode.isGestureEnabled = isGestureEnabled
+            
+            let font: UIFont = isBold ? Font.semibold(17.0) : Font.regular(17.0)
+            
+            self.textNode.attributedText = NSAttributedString(string: text, font: font, textColor: .white)
+            transition.updateTintColor(layer: self.textNode.layer, color: self.contentsColor)
+            self.iconNode.image = icon
+            transition.updateTintColor(layer: self.iconNode.layer, color: self.contentsColor)
+            
+            self.iconNode.isHidden = false
+        
+            textSize = self.textNode.updateLayout(CGSize(width: 200.0, height: .greatestFiniteMagnitude))
+        } else {
+            textSize = self.textNode.bounds.size
+        }
+        
+        let inset: CGFloat = 0.0
+        var textInset: CGFloat = 0.0
+        switch key {
+        case .back:
+            textInset += 11.0
+        default:
+            break
+        }
+        
+        let resultSize: CGSize
+        
+        let textFrame = CGRect(origin: CGPoint(x: inset + textInset, y: floor((height - textSize.height) / 2.0)), size: textSize)
+        self.textNode.position = textFrame.center
+        self.textNode.bounds = CGRect(origin: CGPoint(), size: textFrame.size)
+        
+        if let image = self.iconNode.image {
+            let iconFrame = CGRect(origin: CGPoint(x: inset, y: floor((height - image.size.height) / 2.0)), size: image.size).offsetBy(dx: iconOffset.x, dy: iconOffset.y)
+            self.iconNode.position = iconFrame.center
+            self.iconNode.bounds = CGRect(origin: CGPoint(), size: iconFrame.size)
+            
+            if case .back = key {
+                self.backIconLayer.position = iconFrame.center
+                self.backIconLayer.bounds = CGRect(origin: CGPoint(), size: iconFrame.size)
+                
+                self.iconNode.isHidden = true
+                self.backIconLayer.isHidden = false
+            } else {
+                self.iconNode.isHidden = false
+                self.backIconLayer.isHidden = true
+            }
+            
+            let size = CGSize(width: image.size.width + inset * 2.0, height: height)
+            self.containerNode.frame = CGRect(origin: CGPoint(), size: size)
+            self.contextSourceNode.frame = CGRect(origin: CGPoint(), size: size)
+            resultSize = size
+        } else {
+            let size = CGSize(width: textSize.width + inset * 2.0, height: height)
+            self.containerNode.frame = CGRect(origin: CGPoint(), size: size)
+            self.contextSourceNode.frame = CGRect(origin: CGPoint(), size: size)
+            resultSize = size
+        }
+        
+        let diameter: CGFloat = 32.0
+        let backgroundWidth: CGFloat
+        if self.iconNode.image != nil {
+            backgroundWidth = diameter
+        } else {
+            backgroundWidth = max(diameter, resultSize.width + 12.0 * 2.0)
+        }
+        let backgroundFrame = CGRect(origin: CGPoint(x: floor((resultSize.width - backgroundWidth) * 0.5), y: floor((resultSize.height - diameter) * 0.5)), size: CGSize(width: backgroundWidth, height: diameter))
+        transition.updateFrame(node: self.backgroundNode, frame: backgroundFrame)
+        self.backgroundNode.update(size: backgroundFrame.size, cornerRadius: diameter * 0.5, transition: transition)
+        
+        self.hitTestSlop = UIEdgeInsets(top: -2.0, left: -12.0, bottom: -2.0, right: -12.0)
+        
+        return resultSize
+    }
+}

submodules/StatisticsUI/Sources/BoostHeaderItem.swift

@@ -0,0 +1,539 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import Markdown
+import ComponentFlow
+import PremiumUI
+import MultilineTextComponent
+import BundleIconComponent
+import PlainButtonComponent
+import AccountContext
+
+final class BoostHeaderItem: ItemListControllerHeaderItem {
+    let context: AccountContext
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let status: ChannelBoostStatus?
+    let title: String
+    let text: String
+    let openBoost: () -> Void
+    let createGiveaway: () -> Void
+    let openFeatures: () -> Void
+    let back: () -> Void
+    let updateStatusBar: (StatusBarStyle) -> Void
+    
+    init(context: AccountContext, theme: PresentationTheme, strings: PresentationStrings, status: ChannelBoostStatus?, title: String, text: String, openBoost: @escaping () -> Void, createGiveaway: @escaping () -> Void, openFeatures: @escaping () -> Void, back: @escaping () -> Void, updateStatusBar: @escaping (StatusBarStyle) -> Void) {
+        self.context = context
+        self.theme = theme
+        self.strings = strings
+        self.status = status
+        self.title = title
+        self.text = text
+        self.openBoost = openBoost
+        self.createGiveaway = createGiveaway
+        self.openFeatures = openFeatures
+        self.back = back
+        self.updateStatusBar = updateStatusBar
+    }
+    
+    func isEqual(to: ItemListControllerHeaderItem) -> Bool {
+        if let item = to as? BoostHeaderItem {
+            return self.theme === item.theme && self.title == item.title && self.text == item.text && self.status == item.status
+        } else {
+            return false
+        }
+    }
+    
+    func node(current: ItemListControllerHeaderItemNode?) -> ItemListControllerHeaderItemNode {
+        if let current = current as? BoostHeaderItemNode {
+            current.item = self
+            return current
+        } else {
+            return BoostHeaderItemNode(item: self)
+        }
+    }
+}
+
+private let titleFont = Font.semibold(17.0)
+
+final class BoostHeaderItemNode: ItemListControllerHeaderItemNode {
+    private let backgroundNode: NavigationBackgroundNode
+    private let separatorNode: ASDisplayNode
+    private let whiteTitleNode: ImmediateTextNode
+    private let titleNode: ImmediateTextNode
+    private let backButton = PeerInfoHeaderNavigationButton()
+    
+    private var hostView: ComponentHostView<Empty>?
+    
+    private var component: AnyComponent<Empty>?
+    private var validLayout: ContainerViewLayout?
+        
+    fileprivate var item: BoostHeaderItem {
+        didSet {
+            self.updateItem()
+            if let layout = self.validLayout {
+                let _ = self.updateLayout(layout: layout, transition: .animated(duration: 0.2, curve: .easeInOut))
+            }
+        }
+    }
+    
+    init(item: BoostHeaderItem) {
+        self.item = item
+        
+        self.backgroundNode = NavigationBackgroundNode(color: item.theme.rootController.navigationBar.blurredBackgroundColor)
+        self.backgroundNode.alpha = 0.0
+        self.separatorNode = ASDisplayNode()
+        self.separatorNode.alpha = 0.0
+        
+        self.whiteTitleNode = ImmediateTextNode()
+        self.whiteTitleNode.isUserInteractionEnabled = false
+        self.whiteTitleNode.contentMode = .left
+        self.whiteTitleNode.contentsScale = UIScreen.main.scale
+        
+        self.titleNode = ImmediateTextNode()
+        self.titleNode.alpha = 0.0
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+
+        super.init()
+        
+        self.addSubnode(self.backgroundNode)
+        self.addSubnode(self.separatorNode)
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.whiteTitleNode)
+        self.addSubnode(self.backButton)
+                
+        self.updateItem()
+        
+        self.backButton.action = { [weak self] _, _ in
+            if let self {
+                self.item.back()
+            }
+        }
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        let hostView = ComponentHostView<Empty>()
+        self.hostView = hostView
+        self.view.insertSubview(hostView, at: 0)
+        
+        if let layout = self.validLayout, let component = self.component {
+            let navigationBarHeight: CGFloat = 44.0
+            let statusBarHeight = layout.statusBarHeight ?? 0.0
+            let containerSize = CGSize(width: layout.size.width, height: navigationBarHeight + statusBarHeight + 266.0)
+            
+            let size = hostView.update(
+                transition: .immediate,
+                component: component,
+                environment: {},
+                containerSize: containerSize
+            )
+            hostView.frame = CGRect(origin: CGPoint(x: 0.0, y: -self.contentOffset), size: size)
+        }
+    }
+    
+    func updateItem() {
+        self.backgroundNode.updateColor(color: self.item.theme.rootController.navigationBar.blurredBackgroundColor, transition: .immediate)
+        self.separatorNode.backgroundColor = self.item.theme.rootController.navigationBar.separatorColor
+        
+        self.titleNode.attributedText = NSAttributedString(string: self.item.title, font: titleFont, textColor: self.item.theme.list.itemPrimaryTextColor, paragraphAlignment: .center)
+        self.whiteTitleNode.attributedText = NSAttributedString(string: self.item.title, font: titleFont, textColor: .white, paragraphAlignment: .center)
+    }
+    
+    private var contentOffset: CGFloat = 0.0
+    override func updateContentOffset(_ contentOffset: CGFloat, transition: ContainedViewLayoutTransition) {
+        guard let layout = self.validLayout else {
+            return
+        }
+        self.contentOffset = contentOffset
+        
+        let topPanelAlpha = min(20.0, max(0.0, contentOffset - 44.0)) / 20.0
+        transition.updateAlpha(node: self.backgroundNode, alpha: topPanelAlpha)
+        transition.updateAlpha(node: self.separatorNode, alpha: topPanelAlpha)
+        
+        transition.updateAlpha(node: self.titleNode, alpha: topPanelAlpha)
+        transition.updateAlpha(node: self.whiteTitleNode, alpha: 1.0 - topPanelAlpha)
+        
+        let scrolledUp = topPanelAlpha < 0.5
+        self.backButton.updateContentsColor(backgroundColor: scrolledUp ? UIColor(white: 1.0, alpha: 0.2) : .clear, contentsColor: scrolledUp ? .white : self.item.theme.rootController.navigationBar.accentTextColor, canBeExpanded: !scrolledUp, transition: .animated(duration: 0.2, curve: .easeInOut))
+        
+        if scrolledUp {
+            self.item.updateStatusBar(.White)
+        } else {
+            self.item.updateStatusBar(.Ignore)
+        }
+        
+        if let hostView = self.hostView {
+            hostView.center = CGPoint(x: layout.size.width / 2.0, y: hostView.frame.height / 2.0 - contentOffset)
+        }
+    }
+    
+    override func updateLayout(layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) -> CGFloat {
+        let isFirstTime = self.validLayout == nil
+        let leftInset: CGFloat = 24.0
+        
+        let navigationBarHeight: CGFloat = 44.0
+        let statusBarHeight = layout.statusBarHeight ?? 0.0
+        
+        let constrainedSize = CGSize(width: layout.size.width - leftInset * 2.0, height: CGFloat.greatestFiniteMagnitude)
+        let titleSize = self.titleNode.updateLayout(constrainedSize)
+        let _ = self.whiteTitleNode.updateLayout(constrainedSize)
+       
+        transition.updateFrame(node: self.backgroundNode, frame: CGRect(origin: .zero, size: CGSize(width: layout.size.width, height: statusBarHeight + navigationBarHeight)))
+        transition.updateFrame(node: self.separatorNode, frame: CGRect(origin: CGPoint(x: 0.0, y: statusBarHeight + navigationBarHeight), size: CGSize(width: layout.size.width, height: UIScreenPixel)))
+        
+        self.backgroundNode.update(size: CGSize(width: layout.size.width, height: statusBarHeight + navigationBarHeight), transition: transition)
+               
+        let component = AnyComponent(BoostHeaderComponent(
+            strings: self.item.strings, 
+            text: self.item.text,
+            status: self.item.status,
+            insets: layout.safeInsets,
+            openBoost: self.item.openBoost,
+            createGiveaway: self.item.createGiveaway,
+            openFeatures: self.item.openFeatures
+        ))
+        let containerSize = CGSize(width: layout.size.width, height: navigationBarHeight + statusBarHeight + 266.0)
+        
+        if let hostView = self.hostView {
+            let size = hostView.update(
+                transition: ComponentTransition(transition),
+                component: component,
+                environment: {},
+                containerSize: containerSize
+            )
+            hostView.frame = CGRect(origin: CGPoint(x: 0.0, y: -self.contentOffset), size: size)
+        }
+
+        self.titleNode.bounds = CGRect(origin: .zero, size: titleSize)
+        self.titleNode.position = CGPoint(x: layout.size.width / 2.0, y: statusBarHeight + navigationBarHeight / 2.0)
+       
+        self.whiteTitleNode.bounds = self.titleNode.bounds
+        self.whiteTitleNode.position = self.titleNode.position
+                
+        let backSize = self.backButton.update(key: .back, presentationData: self.item.context.sharedContext.currentPresentationData.with { $0 }, height: 44.0)
+        self.backButton.frame = CGRect(origin: CGPoint(x: layout.safeInsets.left + 16.0, y: statusBarHeight), size: backSize)
+        
+        self.component = component
+        self.validLayout = layout
+        
+        if isFirstTime {
+            self.backButton.updateContentsColor(backgroundColor: UIColor(white: 1.0, alpha: 0.2), contentsColor: .white, canBeExpanded: false, transition: .immediate)
+        }
+        
+        return containerSize.height
+    }
+    
+    override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
+        if let hostView = self.hostView, hostView.frame.contains(point) {
+            return true
+        } else {
+            return super.point(inside: point, with: event)
+        }
+    }
+}
+
+private final class BoostHeaderComponent: CombinedComponent {
+    let strings: PresentationStrings
+    let text: String
+    let status: ChannelBoostStatus?
+    let insets: UIEdgeInsets
+    let openBoost: () -> Void
+    let createGiveaway: () -> Void
+    let openFeatures: () -> Void
+    
+    public init(
+        strings: PresentationStrings,
+        text: String,
+        status: ChannelBoostStatus?,
+        insets: UIEdgeInsets,
+        openBoost: @escaping () -> Void,
+        createGiveaway: @escaping () -> Void,
+        openFeatures: @escaping () -> Void
+    ) {
+        self.strings = strings
+        self.text = text
+        self.status = status
+        self.insets = insets
+        self.openBoost = openBoost
+        self.createGiveaway = createGiveaway
+        self.openFeatures = openFeatures
+    }
+
+    public static func ==(lhs: BoostHeaderComponent, rhs: BoostHeaderComponent) -> Bool {
+        if lhs.strings !== rhs.strings {
+            return false
+        }
+        if lhs.text != rhs.text {
+            return false
+        }
+        if lhs.status != rhs.status {
+            return false
+        }
+        if lhs.insets != rhs.insets {
+            return false
+        }
+        return true
+    }
+
+    public static var body: Body {
+        let background = Child(PremiumGradientBackgroundComponent.self)
+        let stars = Child(BoostHeaderBackgroundComponent.self)
+        let progress = Child(PremiumLimitDisplayComponent.self)
+        let text = Child(MultilineTextComponent.self)
+        
+        let boostButton = Child(PlainButtonComponent.self)
+        let giveawayButton = Child(PlainButtonComponent.self)
+        let featuresButton = Child(PlainButtonComponent.self)
+
+        return { context in
+            let size = context.availableSize
+            
+            let component = context.component
+            let sideInset: CGFloat = 16.0 + component.insets.left
+            
+            let background = background.update(
+                component: PremiumGradientBackgroundComponent(
+                    colors: [
+                        UIColor(rgb: 0x0077ff),
+                        UIColor(rgb: 0x6b93ff),
+                        UIColor(rgb: 0x8878ff),
+                        UIColor(rgb: 0xe46ace)
+                    ],
+                    cornerRadius: 0.0,
+                    topOverscroll: true
+                ),
+                availableSize: size,
+                transition: context.transition
+            )
+            context.add(background
+                .position(CGPoint(x: size.width / 2.0, y: size.height / 2.0))
+            )
+            
+            let stars = stars.update(
+                component: BoostHeaderBackgroundComponent(
+                    isVisible: true,
+                    hasIdleAnimations: true
+                ),
+                availableSize: size,
+                transition: context.transition
+            )
+            context.add(stars
+                .position(CGPoint(x: size.width / 2.0, y: size.height / 2.0 + 10.0))
+            )
+            
+            let boosts: Int
+            let level = component.status?.level ?? 0
+            let position: CGFloat
+            if let status = component.status {
+                if let nextLevelBoosts = status.nextLevelBoosts {
+                    position = CGFloat(status.boosts - status.currentLevelBoosts) / CGFloat(nextLevelBoosts - status.currentLevelBoosts)
+                } else {
+                    position = 1.0
+                }
+                boosts = status.boosts
+            } else {
+                boosts = 0
+                position = 0.0
+            }
+            
+            let inactiveText = component.strings.ChannelBoost_Level("\(level)").string
+            let activeText = component.strings.ChannelBoost_Level("\(level + 1)").string
+            
+            let progress = progress.update(
+                component: PremiumLimitDisplayComponent(
+                    inactiveColor: UIColor.white.withAlphaComponent(0.2),
+                    activeColors: [.white, .white],
+                    inactiveTitle: inactiveText,
+                    inactiveValue: "",
+                    inactiveTitleColor: .white,
+                    activeTitle: "",
+                    activeValue: activeText,
+                    activeTitleColor: UIColor(rgb: 0x6f8fff),
+                    badgeIconName: "Premium/Boost",
+                    badgeText: "\(boosts)",
+                    badgePosition: position,
+                    badgeGraphPosition: position,
+                    invertProgress: true,
+                    isPremiumDisabled: false
+                ),
+                availableSize: CGSize(width: size.width - sideInset * 2.0, height: size.height),
+                transition: context.transition
+            )
+
+            context.add(progress
+                .position(CGPoint(x: size.width / 2.0, y: size.height / 2.0 - 36.0))
+            )
+
+            let font = Font.regular(15.0)
+            let boldFont = Font.semibold(15.0)
+            let markdownAttributes = MarkdownAttributes(body: MarkdownAttributeSet(font: font, textColor: .white), bold: MarkdownAttributeSet(font: boldFont, textColor: .white), link: MarkdownAttributeSet(font: font, textColor: .white), linkAttribute: { _ in return nil})
+            
+            let text = text.update(
+                component: MultilineTextComponent(
+                    text: .markdown(text: component.text, attributes: markdownAttributes),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 0,
+                    lineSpacing: 0.2
+                ),
+                availableSize: CGSize(width: size.width - sideInset * 3.0, height: size.height),
+                transition: context.transition
+            )
+            context.add(text
+                .position(CGPoint(x: size.width / 2.0, y: size.height - 114.0))
+            )
+            
+            let minButtonWidth: CGFloat = 112.0
+//            let buttonSpacing = (size.width - sideInset * 2.0 - minButtonWidth * 3.0) / 2.0
+            let buttonHeight: CGFloat = 58.0
+             
+            let boostButton = boostButton.update(
+                component: PlainButtonComponent(
+                    content: AnyComponent(
+                        BoostButtonComponent(
+                            iconName: "Premium/Boosts/Boost",
+                            title: component.strings.ChannelBoost_Header_Boost
+                        )
+                    ),
+                    effectAlignment: .center,
+                    action: {
+                        component.openBoost()
+                    }
+                ),
+                availableSize: CGSize(width: minButtonWidth, height: buttonHeight),
+                transition: context.transition
+            )
+            context.add(boostButton
+                .position(CGPoint(x: sideInset + minButtonWidth / 2.0, y: size.height - 45.0))
+            )
+            
+            let giveawayButton = giveawayButton.update(
+                component: PlainButtonComponent(
+                    content: AnyComponent(
+                        BoostButtonComponent(
+                            iconName: "Premium/Boosts/Giveaway",
+                            title: component.strings.ChannelBoost_Header_Giveaway
+                        )
+                    ),
+                    effectAlignment: .center,
+                    action: {
+                        component.createGiveaway()
+                    }
+                ),
+                availableSize: CGSize(width: minButtonWidth, height: buttonHeight),
+                transition: context.transition
+            )
+            context.add(giveawayButton
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: size.height - 45.0))
+            )
+            
+            let featuresButton = featuresButton.update(
+                component: PlainButtonComponent(
+                    content: AnyComponent(
+                        BoostButtonComponent(
+                            iconName: "Premium/Boosts/Features",
+                            title: component.strings.ChannelBoost_Header_Features
+                        )
+                    ),
+                    effectAlignment: .center,
+                    action: {
+                        component.openFeatures()
+                    }
+                ),
+                availableSize: CGSize(width: minButtonWidth, height: buttonHeight),
+                transition: context.transition
+            )
+            context.add(featuresButton
+                .position(CGPoint(x: context.availableSize.width - sideInset - minButtonWidth / 2.0, y: size.height - 45.0))
+            )
+            
+            return background.size
+        }
+    }
+}
+
+private final class BoostButtonComponent: CombinedComponent {
+    let iconName: String
+    let title: String
+    
+    public init(
+        iconName: String,
+        title: String
+    ) {
+        self.iconName = iconName
+        self.title = title
+    }
+
+    public static func ==(lhs: BoostButtonComponent, rhs: BoostButtonComponent) -> Bool {
+        if lhs.iconName != rhs.iconName {
+            return false
+        }
+        if lhs.title != rhs.title {
+            return false
+        }
+        return true
+    }
+
+    public static var body: Body {
+        let background = Child(RoundedRectangle.self)
+        let icon = Child(BundleIconComponent.self)
+        let title = Child(MultilineTextComponent.self)
+
+        return { context in
+            let size = context.availableSize
+            let component = context.component
+            
+            let background = background.update(
+                component: RoundedRectangle(
+                    color: UIColor.white.withAlphaComponent(0.2),
+                    cornerRadius: 10.0
+                ),
+                availableSize: context.availableSize,
+                transition: context.transition
+            )
+            context.add(background
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: context.availableSize.height / 2.0))
+            )
+            
+            let icon = icon.update(
+                component: BundleIconComponent(
+                    name: component.iconName,
+                    tintColor: .white
+                ),
+                availableSize: context.availableSize,
+                transition: context.transition
+            )
+            context.add(icon
+                .position(CGPoint(x: size.width / 2.0, y: 21.0))
+            )
+            
+            let title = title.update(
+                component: MultilineTextComponent(
+                    text: .plain(NSAttributedString(
+                        string: component.title,
+                        font: Font.regular(11.0),
+                        textColor: .white
+                    )),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 1
+                ),
+                availableSize: CGSize(width: size.width - 16.0, height: size.height),
+                transition: context.transition
+            )
+            context.add(title
+                .position(CGPoint(x: size.width / 2.0, y: size.height - 16.0))
+            )
+            
+            return background.size
+        }
+    }
+}

submodules/StatisticsUI/Sources/BoostLevelHeaderItem.swift

@@ -0,0 +1,165 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import Markdown
+import PremiumUI
+import ComponentFlow
+
+final class BoostLevelHeaderItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let count: Int32
+    let position: CGFloat
+    let activeText: String
+    let inactiveText: String
+    let sectionId: ItemListSectionId
+    
+    init(theme: PresentationTheme, count: Int32, position: CGFloat, activeText: String, inactiveText: String, sectionId: ItemListSectionId) {
+        self.theme = theme
+        self.count = count
+        self.position = position
+        self.activeText = activeText
+        self.inactiveText = inactiveText
+        self.sectionId = sectionId
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = IncreaseLimitHeaderItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            guard let nodeValue = node() as? IncreaseLimitHeaderItemNode else {
+                assertionFailure()
+                return
+            }
+            
+            let makeLayout = nodeValue.asyncLayout()
+            
+            async {
+                let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                Queue.mainQueue().async {
+                    completion(layout, { _ in
+                        apply()
+                    })
+                }
+            }
+        }
+    }
+}
+
+private let titleFont = Font.semibold(17.0)
+private let textFont = Font.regular(15.0)
+private let boldTextFont = Font.semibold(15.0)
+
+class IncreaseLimitHeaderItemNode: ListViewItemNode {
+    private var hostView: ComponentHostView<Empty>?
+    
+    private var params: (AnyComponent<Empty>, CGSize, ListViewItemNodeLayout)?
+        
+    private var item: BoostLevelHeaderItem?
+    
+    init() {
+        super.init(layerBacked: false, dynamicBounce: false)
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        let hostView = ComponentHostView<Empty>()
+        self.hostView = hostView
+        self.view.addSubview(hostView)
+        
+        if let (component, containerSize, layout) = self.params {
+            let size = hostView.update(
+                transition: .immediate,
+                component: component,
+                environment: {},
+                containerSize: containerSize
+            )
+            hostView.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((layout.size.width - size.width) / 2.0), y: -5.0), size: size)
+        }
+    }
+    
+    func asyncLayout() -> (_ item: BoostLevelHeaderItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        return { item, params, neighbors in
+            let topInset: CGFloat = 2.0
+            
+            let badgeHeight: CGFloat = 200.0
+            let bottomInset: CGFloat = -86.0
+            
+            let contentSize = CGSize(width: params.width, height: topInset + badgeHeight + bottomInset - 5.0)
+            
+            let insets = itemListNeighborsGroupedInsets(neighbors, params)
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    
+                    let gradientColors: [UIColor]
+                    gradientColors = [
+                        UIColor(rgb: 0x0077ff),
+                        UIColor(rgb: 0x6b93ff),
+                        UIColor(rgb: 0x8878ff),
+                        UIColor(rgb: 0xe46ace)
+                    ]
+
+                    let component = AnyComponent(PremiumLimitDisplayComponent(
+                        inactiveColor: item.theme.list.itemBlocksSeparatorColor.withAlphaComponent(0.5),
+                        activeColors: gradientColors,
+                        inactiveTitle: item.inactiveText,
+                        inactiveValue: "",
+                        inactiveTitleColor: item.theme.list.itemPrimaryTextColor,
+                        activeTitle: "",
+                        activeValue: item.activeText,
+                        activeTitleColor: .white,
+                        badgeIconName: "Premium/Boost",
+                        badgeText: "\(item.count)",
+                        badgePosition: item.position,
+                        badgeGraphPosition: item.position,
+                        invertProgress: true,
+                        isPremiumDisabled: false
+                    ))
+                    let containerSize = CGSize(width: layout.size.width - params.leftInset - params.rightInset, height: 200.0)
+                    
+                    if let hostView = strongSelf.hostView {
+                        let size = hostView.update(
+                            transition: .immediate,
+                            component: component,
+                            environment: {},
+                            containerSize: containerSize
+                        )
+                        hostView.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((layout.size.width - size.width) / 2.0), y: -5.0), size: size)
+                    }
+                    
+                    strongSelf.params = (component, containerSize, layout)
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}

submodules/StatisticsUI/Sources/BoostsTabsItem.swift

@@ -0,0 +1,267 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import LegacyComponents
+import ItemListUI
+import PresentationDataUtils
+
+final class BoostsTabsItem: ListViewItem, ItemListItem {
+    enum Tab {
+        case boosts
+        case gifts
+    }
+    
+    let theme: PresentationTheme
+    
+    let boostsText: String
+    let giftsText: String
+    let selectedTab: Tab
+    
+    let sectionId: ItemListSectionId
+    let selectionUpdated: (Tab) -> Void
+    
+    init(theme: PresentationTheme, boostsText: String, giftsText: String, selectedTab: Tab, sectionId: ItemListSectionId, selectionUpdated: @escaping (Tab) -> Void) {
+        self.theme = theme
+        self.boostsText = boostsText
+        self.giftsText = giftsText
+        self.selectedTab = selectedTab
+        self.sectionId = sectionId
+        self.selectionUpdated = selectionUpdated
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = BoostsTabsItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? BoostsTabsItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+}
+
+private final class BoostsTabsItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let boostsButton: HighlightTrackingButtonNode
+    private let boostsTextNode: TextNode
+    
+    private let giftsButton: HighlightTrackingButtonNode
+    private let giftsTextNode: TextNode
+    
+    private let selectionNode: ASImageNode
+    
+    private var item: BoostsTabsItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.maskNode = ASImageNode()
+        
+        self.boostsButton = HighlightTrackingButtonNode()
+        
+        self.boostsTextNode = TextNode()
+        self.boostsTextNode.isUserInteractionEnabled = false
+        self.boostsTextNode.displaysAsynchronously = false
+        
+        self.giftsButton = HighlightTrackingButtonNode()
+        
+        self.giftsTextNode = TextNode()
+        self.giftsTextNode.isUserInteractionEnabled = false
+        self.giftsTextNode.displaysAsynchronously = false
+        
+        self.selectionNode = ASImageNode()
+        self.selectionNode.displaysAsynchronously = false
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.boostsTextNode)
+        self.addSubnode(self.giftsTextNode)
+        self.addSubnode(self.selectionNode)
+        self.addSubnode(self.boostsButton)
+        self.addSubnode(self.giftsButton)
+        
+        self.boostsButton.addTarget(self, action: #selector(self.boostsPressed), forControlEvents: .touchUpInside)
+        self.giftsButton.addTarget(self, action: #selector(self.giftsPressed), forControlEvents: .touchUpInside)
+    }
+    
+    @objc private func boostsPressed() {
+        if let item = self.item {
+            item.selectionUpdated(.boosts)
+        }
+    }
+    
+    @objc private func giftsPressed() {
+        if let item = self.item {
+            item.selectionUpdated(.gifts)
+        }
+    }
+    
+    func asyncLayout() -> (_ item: BoostsTabsItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        let makeBoostsTextLayout = TextNode.asyncLayout(self.boostsTextNode)
+        let makeGiftsTextLayout = TextNode.asyncLayout(self.giftsTextNode)
+        
+        return { item, params, neighbors in
+            var themeUpdated = false
+            if currentItem?.theme !== item.theme {
+                themeUpdated = true
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            
+            let accentColor = item.theme.list.itemAccentColor
+            let secondaryColor = item.theme.list.itemSecondaryTextColor
+            
+            let (boostsTextLayout, boostsTextApply) = makeBoostsTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.boostsText, font: Font.medium(14.0), textColor: item.selectedTab == .boosts ? accentColor : secondaryColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (giftsTextLayout, giftsTextApply) = makeGiftsTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.giftsText, font: Font.medium(14.0), textColor: item.selectedTab == .gifts ? accentColor : secondaryColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            contentSize = CGSize(width: params.width, height: 48.0)
+            insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                    strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    
+                    if themeUpdated {
+                        strongSelf.selectionNode.image = generateImage(CGSize(width: 4.0, height: 3.0), rotatedContext: { size, context in
+                            context.clear(CGRect(origin: .zero, size: size))
+                            
+                            context.setFillColor(item.theme.list.itemAccentColor.cgColor)
+                            
+                            let path = UIBezierPath(roundedRect: CGRect(origin: .zero, size: CGSize(width: size.width, height: 4.0)), cornerRadius: 2.0)
+                            context.addPath(path.cgPath)
+                            context.fillPath()
+                        })?.stretchableImage(withLeftCapWidth: 2, topCapHeight: 0)
+                    }
+                    
+                    if strongSelf.backgroundNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                    }
+                    if strongSelf.topStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                    }
+                    if strongSelf.bottomStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                    }
+                    if strongSelf.maskNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    
+                    let hasCorners = itemListHasRoundedBlockLayout(params)
+                    var hasTopCorners = false
+                    var hasBottomCorners = false
+                    switch neighbors.top {
+                        case .sameSection(false):
+                            strongSelf.topStripeNode.isHidden = true
+                        default:
+                            hasTopCorners = true
+                            strongSelf.topStripeNode.isHidden = hasCorners
+                    }
+                    let bottomStripeInset: CGFloat
+                    let bottomStripeOffset: CGFloat
+                    switch neighbors.bottom {
+                        case .sameSection(false):
+                            bottomStripeInset = 0.0
+                            bottomStripeOffset = -separatorHeight
+                            strongSelf.bottomStripeNode.isHidden = false
+                        default:
+                            bottomStripeInset = 0.0
+                            bottomStripeOffset = 0.0
+                            hasBottomCorners = true
+                            strongSelf.bottomStripeNode.isHidden = hasCorners
+                    }
+                    
+                    strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.theme, top: hasTopCorners, bottom: hasBottomCorners) : nil
+                    
+                    strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                    strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset, height: separatorHeight))
+                    
+                    let _ = boostsTextApply()
+                    let _ = giftsTextApply()
+                    
+                    strongSelf.boostsTextNode.frame = CGRect(origin: CGPoint(x: params.leftInset + 16.0, y: 16.0), size: boostsTextLayout.size)
+                    strongSelf.giftsTextNode.frame = CGRect(origin: CGPoint(x: params.leftInset + 16.0 + boostsTextLayout.size.width + 27.0, y: 16.0), size: giftsTextLayout.size)
+                    
+                    strongSelf.boostsButton.frame = strongSelf.boostsTextNode.frame.insetBy(dx: -10.0, dy: -10.0)
+                    strongSelf.giftsButton.frame = strongSelf.giftsTextNode.frame.insetBy(dx: -10.0, dy: -10.0)
+                    
+                    let selectionHeight: CGFloat = 3.0
+                    let selectionFrame: CGRect
+                    
+                    switch item.selectedTab {
+                    case .boosts:
+                        selectionFrame = CGRect(x: strongSelf.boostsTextNode.frame.minX, y: contentSize.height - selectionHeight, width: strongSelf.boostsTextNode.frame.width, height: selectionHeight)
+                    case .gifts:
+                        selectionFrame = CGRect(x: strongSelf.giftsTextNode.frame.minX, y: contentSize.height - selectionHeight, width: strongSelf.giftsTextNode.frame.width, height: selectionHeight)
+                    }
+                    
+                    var transition: ContainedViewLayoutTransition = .immediate
+                    if let currentItem, currentItem.selectedTab != item.selectedTab {
+                        transition = .animated(duration: 0.3, curve: .spring)
+                    }
+                    transition.updateFrame(node: strongSelf.selectionNode, frame: selectionFrame)
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}

submodules/StatisticsUI/Sources/GroupStatsController.swift

@@ -0,0 +1,910 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import TelegramStringFormatting
+import ItemListUI
+import PresentationDataUtils
+import AccountContext
+import PresentationDataUtils
+import AppBundle
+import GraphUI
+import ItemListPeerItem
+import ItemListPeerActionItem
+
+private let maxUsersDisplayedLimit: Int32 = 10
+private let maxUsersDisplayedHighLimit: Int32 = 12
+
+private final class GroupStatsControllerArguments {
+    let context: AccountContext
+    let loadDetailedGraph: (StatsGraph, Int64) -> Signal<StatsGraph?, NoError>
+    let openPeer: (EnginePeer) -> Void
+    let openPeerHistory: (EnginePeer.Id) -> Void
+    let openPeerAdminActions: (EnginePeer.Id) -> Void
+    let promotePeer: (EnginePeer.Id) -> Void
+    let expandTopPosters: () -> Void
+    let expandTopAdmins: () -> Void
+    let expandTopInviters: () -> Void
+    let setPostersPeerIdWithRevealedOptions: (EnginePeer.Id?, EnginePeer.Id?) -> Void
+    let setAdminsPeerIdWithRevealedOptions: (EnginePeer.Id?, EnginePeer.Id?) -> Void
+    let setInvitersPeerIdWithRevealedOptions: (EnginePeer.Id?, EnginePeer.Id?) -> Void
+    
+    init(context: AccountContext, loadDetailedGraph: @escaping (StatsGraph, Int64) -> Signal<StatsGraph?, NoError>, openPeer: @escaping (EnginePeer) -> Void, openPeerHistory: @escaping (EnginePeer.Id) -> Void, openPeerAdminActions: @escaping (EnginePeer.Id) -> Void, promotePeer: @escaping (EnginePeer.Id) -> Void, expandTopPosters: @escaping () -> Void, expandTopAdmins: @escaping () -> Void, expandTopInviters: @escaping () -> Void, setPostersPeerIdWithRevealedOptions: @escaping (EnginePeer.Id?, EnginePeer.Id?) -> Void, setAdminsPeerIdWithRevealedOptions: @escaping (EnginePeer.Id?, EnginePeer.Id?) -> Void, setInvitersPeerIdWithRevealedOptions: @escaping (EnginePeer.Id?, EnginePeer.Id?) -> Void) {
+        self.context = context
+        self.loadDetailedGraph = loadDetailedGraph
+        self.openPeer = openPeer
+        self.openPeerHistory = openPeerHistory
+        self.openPeerAdminActions = openPeerAdminActions
+        self.promotePeer = promotePeer
+        self.expandTopPosters = expandTopPosters
+        self.expandTopAdmins = expandTopAdmins
+        self.expandTopInviters = expandTopInviters
+        self.setPostersPeerIdWithRevealedOptions = setPostersPeerIdWithRevealedOptions
+        self.setAdminsPeerIdWithRevealedOptions = setAdminsPeerIdWithRevealedOptions
+        self.setInvitersPeerIdWithRevealedOptions = setInvitersPeerIdWithRevealedOptions
+    }
+}
+
+private enum StatsSection: Int32 {
+    case overview
+    case growth
+    case members
+    case newMembersBySource
+    case languages
+    case messages
+    case actions
+    case topHours
+    case topWeekdays
+    case topPosters
+    case topAdmins
+    case topInviters
+}
+
+private enum StatsEntry: ItemListNodeEntry {
+    case overviewTitle(PresentationTheme, String, String)
+    case overview(PresentationTheme, GroupStats)
+    
+    case growthTitle(PresentationTheme, String)
+    case growthGraph(PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsGraph, ChartType)
+    
+    case membersTitle(PresentationTheme, String)
+    case membersGraph(PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsGraph, ChartType)
+     
+    case newMembersBySourceTitle(PresentationTheme, String)
+    case newMembersBySourceGraph(PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsGraph, ChartType)
+    
+    case languagesTitle(PresentationTheme, String)
+    case languagesGraph(PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsGraph, ChartType)
+        
+    case messagesTitle(PresentationTheme, String)
+    case messagesGraph(PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsGraph, ChartType)
+    
+    case actionsTitle(PresentationTheme, String)
+    case actionsGraph(PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsGraph, ChartType)
+    
+    case topHoursTitle(PresentationTheme, String)
+    case topHoursGraph(PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsGraph, ChartType)
+    
+    case topWeekdaysTitle(PresentationTheme, String)
+    case topWeekdaysGraph(PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsGraph, ChartType)
+    
+    case topPostersTitle(PresentationTheme, String, String)
+    case topPoster(Int32, PresentationTheme, PresentationStrings, PresentationDateTimeFormat, EnginePeer, GroupStatsTopPoster, Bool, Bool)
+    case topPostersExpand(PresentationTheme, String)
+    
+    case topAdminsTitle(PresentationTheme, String, String)
+    case topAdmin(Int32, PresentationTheme, PresentationStrings, PresentationDateTimeFormat, EnginePeer, GroupStatsTopAdmin, Bool, Bool)
+    case topAdminsExpand(PresentationTheme, String)
+    
+    case topInvitersTitle(PresentationTheme, String, String)
+    case topInviter(Int32, PresentationTheme, PresentationStrings, PresentationDateTimeFormat, EnginePeer, GroupStatsTopInviter, Bool, Bool)
+    case topInvitersExpand(PresentationTheme, String)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .overviewTitle, .overview:
+                return StatsSection.overview.rawValue
+            case .growthTitle, .growthGraph:
+                return StatsSection.growth.rawValue
+            case .membersTitle, .membersGraph:
+                return StatsSection.members.rawValue
+            case .newMembersBySourceTitle, .newMembersBySourceGraph:
+                return StatsSection.newMembersBySource.rawValue
+            case .languagesTitle, .languagesGraph:
+                return StatsSection.languages.rawValue
+            case .messagesTitle, . messagesGraph:
+                return StatsSection.messages.rawValue
+            case .actionsTitle, .actionsGraph:
+                return StatsSection.actions.rawValue
+            case .topHoursTitle, .topHoursGraph:
+                return StatsSection.topHours.rawValue
+            case .topWeekdaysTitle, .topWeekdaysGraph:
+                return StatsSection.topWeekdays.rawValue
+            case .topPostersTitle, .topPoster, .topPostersExpand:
+                return StatsSection.topPosters.rawValue
+            case .topAdminsTitle, .topAdmin, .topAdminsExpand:
+                return StatsSection.topAdmins.rawValue
+            case .topInvitersTitle, .topInviter, .topInvitersExpand:
+                return StatsSection.topInviters.rawValue
+        }
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .overviewTitle:
+                return 0
+            case .overview:
+                return 1
+            case .growthTitle:
+                return 2
+            case .growthGraph:
+                return 3
+            case .membersTitle:
+                return 4
+            case .membersGraph:
+                return 5
+            case .newMembersBySourceTitle:
+                return 6
+            case .newMembersBySourceGraph:
+                return 7
+            case .languagesTitle:
+                return 8
+            case .languagesGraph:
+                return 9
+            case .messagesTitle:
+                return 10
+            case .messagesGraph:
+                return 11
+            case .actionsTitle:
+                return 12
+            case .actionsGraph:
+                return 13
+            case .topHoursTitle:
+                return 14
+            case .topHoursGraph:
+                return 15
+            case .topWeekdaysTitle:
+                return 16
+            case .topWeekdaysGraph:
+                return 17
+            case .topPostersTitle:
+                return 1000
+            case let .topPoster(index, _, _, _, _, _, _, _):
+                return 1001 + index
+            case .topPostersExpand:
+                return 1999
+            case .topAdminsTitle:
+                return 2000
+            case let .topAdmin(index, _, _, _, _, _, _, _):
+                return 2001 + index
+            case .topAdminsExpand:
+                return 2999
+            case .topInvitersTitle:
+                return 3000
+            case let .topInviter(index, _, _, _, _, _, _, _):
+                return 3001 + index
+            case .topInvitersExpand:
+                return 3999
+        }
+    }
+    
+    static func ==(lhs: StatsEntry, rhs: StatsEntry) -> Bool {
+        switch lhs {
+            case let .overviewTitle(lhsTheme, lhsText, lhsDates):
+                if case let .overviewTitle(rhsTheme, rhsText, rhsDates) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsDates == rhsDates {
+                    return true
+                } else {
+                    return false
+                }
+            case let .overview(lhsTheme, lhsStats):
+                if case let .overview(rhsTheme, rhsStats) = rhs, lhsTheme === rhsTheme, lhsStats == rhsStats {
+                    return true
+                } else {
+                    return false
+                }
+            case let .growthTitle(lhsTheme, lhsText):
+                if case let .growthTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .growthGraph(lhsTheme, lhsStrings, lhsDateTimeFormat, lhsGraph, lhsType):
+                if case let .growthGraph(rhsTheme, rhsStrings, rhsDateTimeFormat, rhsGraph, rhsType) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsGraph == rhsGraph, lhsType == rhsType {
+                    return true
+                } else {
+                    return false
+                }
+            case let .membersTitle(lhsTheme, lhsText):
+                if case let .membersTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .membersGraph(lhsTheme, lhsStrings, lhsDateTimeFormat, lhsGraph, lhsType):
+                if case let .membersGraph(rhsTheme, rhsStrings, rhsDateTimeFormat, rhsGraph, rhsType) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsGraph == rhsGraph, lhsType == rhsType {
+                    return true
+                } else {
+                    return false
+                }
+            case let .newMembersBySourceTitle(lhsTheme, lhsText):
+                if case let .newMembersBySourceTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .newMembersBySourceGraph(lhsTheme, lhsStrings, lhsDateTimeFormat, lhsGraph, lhsType):
+                if case let .newMembersBySourceGraph(rhsTheme, rhsStrings, rhsDateTimeFormat, rhsGraph, rhsType) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsGraph == rhsGraph, lhsType == rhsType {
+                    return true
+                } else {
+                    return false
+                }
+            case let .languagesTitle(lhsTheme, lhsText):
+                if case let .languagesTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+            }
+            case let .languagesGraph(lhsTheme, lhsStrings, lhsDateTimeFormat, lhsGraph, lhsType):
+                if case let .languagesGraph(rhsTheme, rhsStrings, rhsDateTimeFormat, rhsGraph, rhsType) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsGraph == rhsGraph, lhsType == rhsType {
+                    return true
+                } else {
+                    return false
+                }
+            case let .messagesTitle(lhsTheme, lhsText):
+                if case let .messagesTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+            }
+            case let .messagesGraph(lhsTheme, lhsStrings, lhsDateTimeFormat, lhsGraph, lhsType):
+                if case let .messagesGraph(rhsTheme, rhsStrings, rhsDateTimeFormat, rhsGraph, rhsType) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsGraph == rhsGraph, lhsType == rhsType {
+                    return true
+                } else {
+                    return false
+                }
+            case let .actionsTitle(lhsTheme, lhsText):
+                if case let .actionsTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+            }
+            case let .actionsGraph(lhsTheme, lhsStrings, lhsDateTimeFormat, lhsGraph, lhsType):
+                if case let .actionsGraph(rhsTheme, rhsStrings, rhsDateTimeFormat, rhsGraph, rhsType) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsGraph == rhsGraph, lhsType == rhsType {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topHoursTitle(lhsTheme, lhsText):
+                if case let .topHoursTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+            }
+            case let .topHoursGraph(lhsTheme, lhsStrings, lhsDateTimeFormat, lhsGraph, lhsType):
+                if case let .topHoursGraph(rhsTheme, rhsStrings, rhsDateTimeFormat, rhsGraph, rhsType) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsGraph == rhsGraph, lhsType == rhsType {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topWeekdaysTitle(lhsTheme, lhsText):
+                if case let .topWeekdaysTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+            }
+            case let .topWeekdaysGraph(lhsTheme, lhsStrings, lhsDateTimeFormat, lhsGraph, lhsType):
+                if case let .topWeekdaysGraph(rhsTheme, rhsStrings, rhsDateTimeFormat, rhsGraph, rhsType) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsGraph == rhsGraph, lhsType == rhsType {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topPostersTitle(lhsTheme, lhsText, lhsDates):
+                if case let .topPostersTitle(rhsTheme, rhsText, rhsDates) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsDates == rhsDates {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topPoster(lhsIndex, lhsTheme, lhsStrings, lhsDateTimeFormat, lhsPeer, lhsTopPoster, lhsRevealed, lhsCanPromote):
+                if case let .topPoster(rhsIndex, rhsTheme, rhsStrings, rhsDateTimeFormat, rhsPeer, rhsTopPoster, rhsRevealed, rhsCanPromote) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsPeer == rhsPeer, lhsTopPoster == rhsTopPoster, lhsRevealed == rhsRevealed, lhsCanPromote == rhsCanPromote {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topPostersExpand(lhsTheme, lhsText):
+                if case let .topPostersExpand(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topAdminsTitle(lhsTheme, lhsText, lhsDates):
+                if case let .topAdminsTitle(rhsTheme, rhsText, rhsDates) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsDates == rhsDates {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topAdmin(lhsIndex, lhsTheme, lhsStrings, lhsDateTimeFormat, lhsPeer, lhsTopAdmin, lhsRevealed, lhsCanPromote):
+                if case let .topAdmin(rhsIndex, rhsTheme, rhsStrings, rhsDateTimeFormat, rhsPeer, rhsTopAdmin, rhsRevealed, rhsCanPromote) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsPeer == rhsPeer, lhsTopAdmin == rhsTopAdmin, lhsRevealed == rhsRevealed, lhsCanPromote == rhsCanPromote {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topAdminsExpand(lhsTheme, lhsText):
+                if case let .topAdminsExpand(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topInvitersTitle(lhsTheme, lhsText, lhsDates):
+                if case let .topInvitersTitle(rhsTheme, rhsText, rhsDates) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsDates == rhsDates {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topInviter(lhsIndex, lhsTheme, lhsStrings, lhsDateTimeFormat, lhsPeer, lhsTopInviter, lhsRevealed, lhsCanPromote):
+                if case let .topInviter(rhsIndex, rhsTheme, rhsStrings, rhsDateTimeFormat, rhsPeer, rhsTopInviter, rhsRevealed, rhsCanPromote) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsPeer == rhsPeer, lhsTopInviter == rhsTopInviter, lhsRevealed == rhsRevealed, lhsCanPromote == rhsCanPromote {
+                    return true
+                } else {
+                    return false
+                }
+            case let .topInvitersExpand(lhsTheme, lhsText):
+                if case let .topInvitersExpand(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: StatsEntry, rhs: StatsEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! GroupStatsControllerArguments
+        switch self {
+            case let .overviewTitle(_, text, dates):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, accessoryText: ItemListSectionHeaderAccessoryText(value: dates, color: .generic), sectionId: self.section)
+            case let .growthTitle(_, text),
+                 let .membersTitle(_, text),
+                 let .newMembersBySourceTitle(_, text),
+                 let .languagesTitle(_, text),
+                 let .messagesTitle(_, text),
+                 let .actionsTitle(_, text),
+                 let .topHoursTitle(_, text),
+                 let .topWeekdaysTitle(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .topPostersTitle(_, text, dates),
+                 let .topAdminsTitle(_, text, dates),
+                 let .topInvitersTitle(_, text, dates):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, accessoryText: ItemListSectionHeaderAccessoryText(value: dates, color: .generic), sectionId: self.section)
+            case let .overview(_, stats):
+                return StatsOverviewItem(context: arguments.context, presentationData: presentationData, isGroup: true, stats: stats, sectionId: self.section, style: .blocks)
+            case let .growthGraph(_, _, _, graph, type),
+                 let .membersGraph(_, _, _, graph, type),
+                 let .newMembersBySourceGraph(_, _, _, graph, type),
+                 let .languagesGraph(_, _, _, graph, type),
+                 let .messagesGraph(_, _, _, graph, type),
+                 let .actionsGraph(_, _, _, graph, type),
+                 let .topHoursGraph(_, _, _, graph, type),
+                 let .topWeekdaysGraph(_, _, _, graph, type):
+                return StatsGraphItem(presentationData: presentationData, graph: graph, type: type, sectionId: self.section, style: .blocks)
+            case let .topPoster(_, _, strings, dateTimeFormat, peer, topPoster, revealed, canPromote):
+                var textComponents: [String] = []
+                if topPoster.messageCount > 0 {
+                    textComponents.append(strings.Stats_GroupTopPosterMessages(topPoster.messageCount))
+                    if topPoster.averageChars > 0 {
+                        textComponents.append(strings.Stats_GroupTopPosterChars(topPoster.averageChars))
+                    }
+                }
+                var options: [ItemListPeerItemRevealOption] = []
+                if !peer.isDeleted {
+                    options.append(ItemListPeerItemRevealOption(type: .accent, title: strings.Stats_GroupTopPoster_History, action: {
+                        arguments.openPeerHistory(peer.id)
+                    }))
+                    if canPromote && arguments.context.account.peerId != peer.id {
+                        options.append(ItemListPeerItemRevealOption(type: .neutral, title: strings.Stats_GroupTopPoster_Promote, action: {
+                            arguments.promotePeer(peer.id)
+                        }))
+                    }
+                }
+                return ItemListPeerItem(presentationData: presentationData, dateTimeFormat: dateTimeFormat, nameDisplayOrder: .firstLast, context: arguments.context, peer: peer, height: .generic, aliasHandling: .standard, nameColor: .primary, nameStyle: .plain, presence: nil, text: .text(textComponents.joined(separator: ", "), .secondary), label: .none, editing: ItemListPeerItemEditing(editable: true, editing: false, revealed: revealed), revealOptions: ItemListPeerItemRevealOptions(options: options), switchValue: nil, enabled: true, highlighted: false, selectable: arguments.context.account.peerId != peer.id, sectionId: self.section, action: {
+                    arguments.openPeer(peer)
+                }, setPeerIdWithRevealedOptions: { peerId, fromPeerId in
+                    arguments.setPostersPeerIdWithRevealedOptions(peerId, fromPeerId)
+                }, removePeer: { _ in })
+            case let .topPostersExpand(theme, title):
+                return ItemListPeerActionItem(presentationData: presentationData, icon: PresentationResourcesItemList.downArrowImage(theme), title: title, sectionId: self.section, editing: false, action: {
+                    arguments.expandTopPosters()
+                })
+            case let .topAdmin(_, _, strings, dateTimeFormat, peer, topAdmin, revealed, canPromote):
+                var textComponents: [String] = []
+                if topAdmin.deletedCount > 0 {
+                    textComponents.append(strings.Stats_GroupTopAdminDeletions(topAdmin.deletedCount))
+                }
+                if topAdmin.kickedCount > 0 {
+                    textComponents.append(strings.Stats_GroupTopAdminKicks(topAdmin.kickedCount))
+                }
+                if topAdmin.bannedCount > 0 {
+                    textComponents.append(strings.Stats_GroupTopAdminBans(topAdmin.bannedCount))
+                }
+                var options: [ItemListPeerItemRevealOption] = []
+                if !peer.isDeleted {
+                    options.append(ItemListPeerItemRevealOption(type: .accent, title: strings.Stats_GroupTopAdmin_Actions, action: {
+                        arguments.openPeerAdminActions(peer.id)
+                    }))
+                    if canPromote && arguments.context.account.peerId != peer.id {
+                        options.append(ItemListPeerItemRevealOption(type: .neutral, title: strings.Stats_GroupTopAdmin_Promote, action: {
+                            arguments.promotePeer(peer.id)
+                        }))
+                    }
+                }
+                return ItemListPeerItem(presentationData: presentationData, dateTimeFormat: dateTimeFormat, nameDisplayOrder: .firstLast, context: arguments.context, peer: peer, height: .generic, aliasHandling: .standard, nameColor: .primary, nameStyle: .plain, presence: nil, text: .text(textComponents.joined(separator: ", "), .secondary), label: .none, editing: ItemListPeerItemEditing(editable: true, editing: false, revealed: revealed), revealOptions: ItemListPeerItemRevealOptions(options: options), switchValue: nil, enabled: true, highlighted: false, selectable: arguments.context.account.peerId != peer.id, sectionId: self.section, action: {
+                    arguments.openPeer(peer)
+                }, setPeerIdWithRevealedOptions: { peerId, fromPeerId in
+                    arguments.setAdminsPeerIdWithRevealedOptions(peerId, fromPeerId)
+                }, removePeer: { _ in })
+            case let .topAdminsExpand(theme, title):
+                return ItemListPeerActionItem(presentationData: presentationData, icon: PresentationResourcesItemList.downArrowImage(theme), title: title, sectionId: self.section, editing: false, action: {
+                    arguments.expandTopAdmins()
+                })
+            case let .topInviter(_, _, strings, dateTimeFormat, peer, topInviter, revealed, canPromote):
+                var textComponents: [String] = []
+                textComponents.append(strings.Stats_GroupTopInviterInvites(topInviter.inviteCount))
+                var options: [ItemListPeerItemRevealOption] = []
+                if !peer.isDeleted {
+                    options.append(ItemListPeerItemRevealOption(type: .accent, title: strings.Stats_GroupTopPoster_History, action: {
+                        arguments.openPeerHistory(peer.id)
+                    }))
+                    if canPromote && arguments.context.account.peerId != peer.id {
+                        options.append(ItemListPeerItemRevealOption(type: .neutral, title: strings.Stats_GroupTopPoster_Promote, action: {
+                            arguments.promotePeer(peer.id)
+                        }))
+                    }
+                }
+                return ItemListPeerItem(presentationData: presentationData, dateTimeFormat: dateTimeFormat, nameDisplayOrder: .firstLast, context: arguments.context, peer: peer, height: .generic, aliasHandling: .standard, nameColor: .primary, nameStyle: .plain, presence: nil, text: .text(textComponents.joined(separator: ", "), .secondary), label: .none, editing: ItemListPeerItemEditing(editable: true, editing: false, revealed: revealed), revealOptions: ItemListPeerItemRevealOptions(options: options), switchValue: nil, enabled: true, highlighted: false, selectable: arguments.context.account.peerId != peer.id, sectionId: self.section, action: {
+                    arguments.openPeer(peer)
+                }, setPeerIdWithRevealedOptions: { peerId, fromPeerId in
+                    arguments.setInvitersPeerIdWithRevealedOptions(peerId, fromPeerId)
+                }, removePeer: { _ in })
+            case let .topInvitersExpand(theme, title):
+                return ItemListPeerActionItem(presentationData: presentationData, icon: PresentationResourcesItemList.downArrowImage(theme), title: title, sectionId: self.section, editing: false, action: {
+                    arguments.expandTopInviters()
+                })
+        }
+    }
+}
+
+private func groupStatsControllerEntries(accountPeerId: EnginePeer.Id, state: GroupStatsState, data: GroupStats?, channelPeer: EnginePeer, peers: [EnginePeer.Id: EnginePeer]?, presentationData: PresentationData) -> [StatsEntry] {
+    var entries: [StatsEntry] = []
+    
+    if let data = data {
+        let minDate = stringForDate(timestamp: data.period.minDate, strings: presentationData.strings)
+        let maxDate = stringForDate(timestamp: data.period.maxDate, strings: presentationData.strings)
+        let dates = "\(minDate) – \(maxDate)"
+        
+        entries.append(.overviewTitle(presentationData.theme, presentationData.strings.Stats_Overview, dates))
+        entries.append(.overview(presentationData.theme, data))
+    
+        if !data.growthGraph.isEmpty {
+            entries.append(.growthTitle(presentationData.theme, presentationData.strings.Stats_GroupGrowthTitle))
+            entries.append(.growthGraph(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, data.growthGraph, .lines))
+        }
+        
+        if !data.membersGraph.isEmpty {
+            entries.append(.membersTitle(presentationData.theme, presentationData.strings.Stats_GroupMembersTitle))
+            entries.append(.membersGraph(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, data.membersGraph, .lines))
+        }
+
+        if !data.newMembersBySourceGraph.isEmpty {
+            entries.append(.newMembersBySourceTitle(presentationData.theme, presentationData.strings.Stats_GroupNewMembersBySourceTitle))
+            entries.append(.newMembersBySourceGraph(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, data.newMembersBySourceGraph, .bars))
+        }
+        
+        if !data.languagesGraph.isEmpty {
+            entries.append(.languagesTitle(presentationData.theme, presentationData.strings.Stats_GroupLanguagesTitle))
+            entries.append(.languagesGraph(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, data.languagesGraph, .pie))
+        }
+
+        if !data.messagesGraph.isEmpty {
+            entries.append(.messagesTitle(presentationData.theme, presentationData.strings.Stats_GroupMessagesTitle))
+            entries.append(.messagesGraph(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, data.messagesGraph, .bars))
+        }
+
+        if !data.actionsGraph.isEmpty {
+            entries.append(.actionsTitle(presentationData.theme, presentationData.strings.Stats_GroupActionsTitle))
+            entries.append(.actionsGraph(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, data.actionsGraph, .lines))
+        }
+
+        if !data.topHoursGraph.isEmpty {
+            entries.append(.topHoursTitle(presentationData.theme, presentationData.strings.Stats_GroupTopHoursTitle))
+            entries.append(.topHoursGraph(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, data.topHoursGraph, .hourlyStep))
+        }
+        
+        if !data.topWeekdaysGraph.isEmpty {
+            entries.append(.topWeekdaysTitle(presentationData.theme, presentationData.strings.Stats_GroupTopWeekdaysTitle))
+            entries.append(.topWeekdaysGraph(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, data.topWeekdaysGraph, .pie))
+        }
+                
+        if let peers = peers {
+            let canPromote = canEditAdminRights(accountPeerId: accountPeerId, channelPeer: channelPeer, initialParticipant: nil)
+            if !data.topPosters.isEmpty {
+                entries.append(.topPostersTitle(presentationData.theme, presentationData.strings.Stats_GroupTopPostersTitle, dates))
+                var index: Int32 = 0
+                
+                var topPosters = data.topPosters
+                var effectiveExpanded = state.topPostersExpanded
+                if topPosters.count > maxUsersDisplayedHighLimit && !effectiveExpanded {
+                    topPosters = Array(topPosters.prefix(Int(maxUsersDisplayedLimit)))
+                } else {
+                    effectiveExpanded = true
+                }
+                
+                for topPoster in topPosters {
+                    if let peer = peers[topPoster.peerId], topPoster.messageCount > 0 {
+                        entries.append(.topPoster(index, presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, peer, topPoster, topPoster.peerId == state.posterPeerIdWithRevealedOptions, canPromote))
+                        index += 1
+                    }
+                }
+
+                if !effectiveExpanded {
+                    entries.append(.topPostersExpand(presentationData.theme, presentationData.strings.Stats_GroupShowMoreTopPosters(Int32(data.topPosters.count) - maxUsersDisplayedLimit)))
+                }
+            }
+            if !data.topAdmins.isEmpty {
+                entries.append(.topAdminsTitle(presentationData.theme, presentationData.strings.Stats_GroupTopAdminsTitle, dates))
+                var index: Int32 = 0
+                
+                var topAdmins = data.topAdmins
+                var effectiveExpanded = state.topAdminsExpanded
+                if topAdmins.count > maxUsersDisplayedHighLimit && !effectiveExpanded {
+                    topAdmins = Array(topAdmins.prefix(Int(maxUsersDisplayedLimit)))
+                } else {
+                    effectiveExpanded = true
+                }
+                
+                for topAdmin in data.topAdmins {
+                    if let peer = peers[topAdmin.peerId], (topAdmin.deletedCount + topAdmin.kickedCount + topAdmin.bannedCount) > 0 {
+                        entries.append(.topAdmin(index, presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, peer, topAdmin, topAdmin.peerId == state.adminPeerIdWithRevealedOptions, canPromote))
+                        index += 1
+                    }
+                }
+                
+                if !effectiveExpanded {
+                    entries.append(.topAdminsExpand(presentationData.theme, presentationData.strings.Stats_GroupShowMoreTopAdmins(Int32(data.topAdmins.count) - maxUsersDisplayedLimit)))
+                }
+            }
+            if !data.topInviters.isEmpty {
+                entries.append(.topInvitersTitle(presentationData.theme, presentationData.strings.Stats_GroupTopInvitersTitle, dates))
+                var index: Int32 = 0
+                
+                var topInviters = data.topInviters
+                var effectiveExpanded = state.topInvitersExpanded
+                if topInviters.count > maxUsersDisplayedHighLimit && !effectiveExpanded {
+                    topInviters = Array(topInviters.prefix(Int(maxUsersDisplayedLimit)))
+                } else {
+                    effectiveExpanded = true
+                }
+                
+                for topInviter in data.topInviters {
+                    if let peer = peers[topInviter.peerId], topInviter.inviteCount > 0 {
+                        entries.append(.topInviter(index, presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, peer, topInviter, topInviter.peerId == state.inviterPeerIdWithRevealedOptions, canPromote))
+                        index += 1
+                    }
+                }
+                
+                if !effectiveExpanded {
+                    entries.append(.topInvitersExpand(presentationData.theme, presentationData.strings.Stats_GroupShowMoreTopInviters(Int32(data.topInviters.count) - maxUsersDisplayedLimit)))
+                }
+            }
+        }
+    }
+    
+    return entries
+}
+
+private struct GroupStatsState: Equatable {
+    let topPostersExpanded: Bool
+    let topAdminsExpanded: Bool
+    let topInvitersExpanded: Bool
+    let posterPeerIdWithRevealedOptions: EnginePeer.Id?
+    let adminPeerIdWithRevealedOptions: EnginePeer.Id?
+    let inviterPeerIdWithRevealedOptions: EnginePeer.Id?
+    
+    init() {
+        self.topPostersExpanded = false
+        self.topAdminsExpanded = false
+        self.topInvitersExpanded = false
+        self.posterPeerIdWithRevealedOptions = nil
+        self.adminPeerIdWithRevealedOptions = nil
+        self.inviterPeerIdWithRevealedOptions = nil
+    }
+    
+    init(topPostersExpanded: Bool, topAdminsExpanded: Bool, topInvitersExpanded: Bool, posterPeerIdWithRevealedOptions: EnginePeer.Id?, adminPeerIdWithRevealedOptions: EnginePeer.Id?, inviterPeerIdWithRevealedOptions: EnginePeer.Id?) {
+        self.topPostersExpanded = topPostersExpanded
+        self.topAdminsExpanded = topAdminsExpanded
+        self.topInvitersExpanded = topInvitersExpanded
+        self.posterPeerIdWithRevealedOptions = posterPeerIdWithRevealedOptions
+        self.adminPeerIdWithRevealedOptions = adminPeerIdWithRevealedOptions
+        self.inviterPeerIdWithRevealedOptions = inviterPeerIdWithRevealedOptions
+    }
+  
+    static func ==(lhs: GroupStatsState, rhs: GroupStatsState) -> Bool {
+        if lhs.topPostersExpanded != rhs.topPostersExpanded {
+            return false
+        }
+        if lhs.topAdminsExpanded != rhs.topAdminsExpanded {
+            return false
+        }
+        if lhs.topInvitersExpanded != rhs.topInvitersExpanded {
+            return false
+        }
+        if lhs.posterPeerIdWithRevealedOptions != rhs.posterPeerIdWithRevealedOptions {
+            return false
+        }
+        if lhs.adminPeerIdWithRevealedOptions != rhs.adminPeerIdWithRevealedOptions {
+            return false
+        }
+        if lhs.inviterPeerIdWithRevealedOptions != rhs.inviterPeerIdWithRevealedOptions {
+            return false
+        }
+        return true
+    }
+    
+    func withUpdatedTopPostersExpanded(_ topPostersExpanded: Bool) -> GroupStatsState {
+        return GroupStatsState(topPostersExpanded: topPostersExpanded, topAdminsExpanded: self.topAdminsExpanded, topInvitersExpanded: self.topInvitersExpanded, posterPeerIdWithRevealedOptions: self.posterPeerIdWithRevealedOptions, adminPeerIdWithRevealedOptions: self.adminPeerIdWithRevealedOptions, inviterPeerIdWithRevealedOptions: self.inviterPeerIdWithRevealedOptions)
+    }
+    
+    func withUpdatedTopAdminsExpanded(_ topAdminsExpanded: Bool) -> GroupStatsState {
+        return GroupStatsState(topPostersExpanded: self.topPostersExpanded, topAdminsExpanded: topAdminsExpanded, topInvitersExpanded: self.topInvitersExpanded, posterPeerIdWithRevealedOptions: self.posterPeerIdWithRevealedOptions, adminPeerIdWithRevealedOptions: self.adminPeerIdWithRevealedOptions, inviterPeerIdWithRevealedOptions: self.inviterPeerIdWithRevealedOptions)
+    }
+    
+    func withUpdatedTopInvitersExpanded(_ topInvitersExpanded: Bool) -> GroupStatsState {
+        return GroupStatsState(topPostersExpanded: self.topPostersExpanded, topAdminsExpanded: self.topAdminsExpanded, topInvitersExpanded: topInvitersExpanded, posterPeerIdWithRevealedOptions: self.posterPeerIdWithRevealedOptions, adminPeerIdWithRevealedOptions: self.adminPeerIdWithRevealedOptions, inviterPeerIdWithRevealedOptions: self.inviterPeerIdWithRevealedOptions)
+    }
+    
+    func withUpdatedPosterPeerIdWithRevealedOptions(_ posterPeerIdWithRevealedOptions: EnginePeer.Id?) -> GroupStatsState {
+        return GroupStatsState(topPostersExpanded: self.topPostersExpanded, topAdminsExpanded: self.topAdminsExpanded, topInvitersExpanded: self.topInvitersExpanded, posterPeerIdWithRevealedOptions: posterPeerIdWithRevealedOptions, adminPeerIdWithRevealedOptions: posterPeerIdWithRevealedOptions != nil ? nil : self.adminPeerIdWithRevealedOptions, inviterPeerIdWithRevealedOptions: posterPeerIdWithRevealedOptions != nil ? nil : self.inviterPeerIdWithRevealedOptions)
+    }
+    
+    func withUpdatedAdminPeerIdWithRevealedOptions(_ adminPeerIdWithRevealedOptions: EnginePeer.Id?) -> GroupStatsState {
+        return GroupStatsState(topPostersExpanded: self.topPostersExpanded, topAdminsExpanded: self.topAdminsExpanded, topInvitersExpanded: self.topInvitersExpanded, posterPeerIdWithRevealedOptions: adminPeerIdWithRevealedOptions != nil ? nil : self.posterPeerIdWithRevealedOptions, adminPeerIdWithRevealedOptions: adminPeerIdWithRevealedOptions, inviterPeerIdWithRevealedOptions: adminPeerIdWithRevealedOptions != nil ? nil : self.inviterPeerIdWithRevealedOptions)
+    }
+    
+    func withUpdatedInviterPeerIdWithRevealedOptions(_ inviterPeerIdWithRevealedOptions: EnginePeer.Id?) -> GroupStatsState {
+        return GroupStatsState(topPostersExpanded: self.topPostersExpanded, topAdminsExpanded: self.topAdminsExpanded, topInvitersExpanded: self.topInvitersExpanded, posterPeerIdWithRevealedOptions: inviterPeerIdWithRevealedOptions != nil ? nil : self.posterPeerIdWithRevealedOptions, adminPeerIdWithRevealedOptions: inviterPeerIdWithRevealedOptions != nil ? nil : self.adminPeerIdWithRevealedOptions, inviterPeerIdWithRevealedOptions: inviterPeerIdWithRevealedOptions)
+    }
+}
+
+private func canEditAdminRights(accountPeerId: EnginePeer.Id, channelPeer: EnginePeer, initialParticipant: ChannelParticipant?) -> Bool {
+    if case let .channel(channel) = channelPeer {
+        if channel.flags.contains(.isCreator) {
+            return true
+        } else if let initialParticipant = initialParticipant {
+            switch initialParticipant {
+                case .creator:
+                    return false
+                case let .member(_, _, adminInfo, _, _, _):
+                    if let adminInfo = adminInfo {
+                        return adminInfo.canBeEditedByAccountPeer || adminInfo.promotedBy == accountPeerId
+                    } else {
+                        return channel.hasPermission(.addAdmins)
+                    }
+            }
+        } else {
+            return channel.hasPermission(.addAdmins)
+        }
+    } else if case let .legacyGroup(group) = channelPeer {
+        if case .creator = group.role {
+            return true
+        } else {
+            return false
+        }
+    } else {
+        return false
+    }
+}
+
+public func groupStatsController(context: AccountContext, updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)? = nil, peerId: EnginePeer.Id) -> ViewController {
+    let statePromise = ValuePromise(GroupStatsState())
+    let stateValue = Atomic(value: GroupStatsState())
+    let updateState: ((GroupStatsState) -> GroupStatsState) -> Void = { f in
+        statePromise.set(stateValue.modify { f($0) })
+    }
+    
+    let actionsDisposable = DisposableSet()
+    let dataPromise = Promise<GroupStats?>(nil)
+    let peersPromise = Promise<[EnginePeer.Id: EnginePeer]?>(nil)
+    
+    var openPeerImpl: ((EnginePeer) -> Void)?
+    var openPeerHistoryImpl: ((EnginePeer.Id) -> Void)?
+    var openPeerAdminActionsImpl: ((EnginePeer.Id) -> Void)?
+    var promotePeerImpl: ((EnginePeer.Id) -> Void)?
+    
+    actionsDisposable.add(context.account.viewTracker.peerView(peerId, updateData: true).start())
+        
+    let statsContext = GroupStatsContext(postbox: context.account.postbox, network: context.account.network, accountPeerId: context.account.peerId, peerId: peerId)
+    let dataSignal: Signal<GroupStats?, NoError> = statsContext.state
+    |> map { state in
+        return state.stats
+    } |> afterNext({ [weak statsContext] stats in
+        if let statsContext = statsContext, let stats = stats {
+            if case .OnDemand = stats.topWeekdaysGraph {
+                statsContext.loadGrowthGraph()
+                statsContext.loadMembersGraph()
+                statsContext.loadNewMembersBySourceGraph()
+                statsContext.loadLanguagesGraph()
+                statsContext.loadMessagesGraph()
+                statsContext.loadActionsGraph()
+                statsContext.loadTopHoursGraph()
+                statsContext.loadTopWeekdaysGraph()
+            }
+        }
+    })
+    dataPromise.set(.single(nil) |> then(dataSignal))
+    
+    peersPromise.set(.single(nil) |> then(dataPromise.get()
+    |> filter { value in
+        return value != nil
+    }
+    |> take(1)
+    |> map { stats -> [EnginePeer.Id]? in
+        guard let stats = stats else {
+            return nil
+        }
+        var peerIds = Set<EnginePeer.Id>()
+        peerIds.formUnion(stats.topPosters.map { $0.peerId })
+        peerIds.formUnion(stats.topAdmins.map { $0.peerId })
+        peerIds.formUnion(stats.topInviters.map { $0.peerId })
+        return Array(peerIds)
+    }
+    |> mapToSignal { peerIds -> Signal<[EnginePeer.Id: EnginePeer]?, NoError> in
+        if let peerIds = peerIds {
+            return context.engine.data.get(EngineDataMap(
+                peerIds.map(TelegramEngine.EngineData.Item.Peer.Peer.init)
+            ))
+            |> map { peerMap -> [EnginePeer.Id: EnginePeer]? in
+                return peerMap.compactMapValues { $0 }
+            }
+        } else {
+            return .single([:])
+        }
+    }))
+    
+    let arguments = GroupStatsControllerArguments(context: context, loadDetailedGraph: { graph, x -> Signal<StatsGraph?, NoError> in
+        return statsContext.loadDetailedGraph(graph, x: x)
+    }, openPeer: { peer in
+        openPeerImpl?(peer)
+    }, openPeerHistory: { peerId in
+        openPeerHistoryImpl?(peerId)
+    }, openPeerAdminActions: { peerId in
+        openPeerAdminActionsImpl?(peerId)
+    }, promotePeer: { peerId in
+        promotePeerImpl?(peerId)
+    }, expandTopPosters: {
+        updateState { state in
+            return state.withUpdatedTopPostersExpanded(true)
+        }
+    }, expandTopAdmins: {
+        updateState { state in
+            return state.withUpdatedTopAdminsExpanded(true)
+        }
+    }, expandTopInviters: {
+        updateState { state in
+            return state.withUpdatedTopInvitersExpanded(true)
+        }
+    }, setPostersPeerIdWithRevealedOptions: { peerId, fromPeerId in
+        updateState { state in
+            if (peerId == nil && fromPeerId == state.posterPeerIdWithRevealedOptions) || (peerId != nil && fromPeerId == nil) {
+                return state.withUpdatedPosterPeerIdWithRevealedOptions(peerId)
+            } else {
+                return state
+            }
+        }
+    }, setAdminsPeerIdWithRevealedOptions: { peerId, fromPeerId in
+        updateState { state in
+            if (peerId == nil && fromPeerId == state.adminPeerIdWithRevealedOptions) || (peerId != nil && fromPeerId == nil) {
+                return state.withUpdatedAdminPeerIdWithRevealedOptions(peerId)
+            } else {
+                return state
+            }
+        }
+    }, setInvitersPeerIdWithRevealedOptions: { peerId, fromPeerId in
+        updateState { state in
+            if (peerId == nil && fromPeerId == state.inviterPeerIdWithRevealedOptions) || (peerId != nil && fromPeerId == nil) {
+                return state.withUpdatedInviterPeerIdWithRevealedOptions(peerId)
+            } else {
+                return state
+            }
+        }
+    })
+        
+    let longLoadingSignal: Signal<Bool, NoError> = .single(false) |> then(.single(true) |> delay(2.0, queue: Queue.mainQueue()))
+    
+    let previousData = Atomic<GroupStats?>(value: nil)
+    
+    let presentationData = updatedPresentationData?.signal ?? context.sharedContext.presentationData
+    let signal = combineLatest(statePromise.get(), presentationData, dataPromise.get(), context.account.postbox.loadedPeerWithId(peerId), peersPromise.get(), longLoadingSignal)
+    |> deliverOnMainQueue
+    |> map { state, presentationData, data, channelPeer, peers, longLoading -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        let previous = previousData.swap(data)
+        var emptyStateItem: ItemListControllerEmptyStateItem?
+        if data == nil {
+            if longLoading {
+                emptyStateItem = StatsEmptyStateItem(context: context, theme: presentationData.theme, strings: presentationData.strings)
+            } else {
+                emptyStateItem = ItemListLoadingIndicatorEmptyStateItem(theme: presentationData.theme)
+            }
+        }
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(presentationData.strings.ChannelInfo_Stats), leftNavigationButton: nil, rightNavigationButton: nil, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: true)
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: groupStatsControllerEntries(accountPeerId: context.account.peerId, state: state, data: data, channelPeer: EnginePeer(channelPeer), peers: peers, presentationData: presentationData), style: .blocks, emptyStateItem: emptyStateItem, crossfadeState: previous == nil, animateChanges: false)
+        
+        return (controllerState, (listState, arguments))
+    }
+    |> afterDisposed {
+        actionsDisposable.dispose()
+        let _ = statsContext.state
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    controller.contentOffsetChanged = { [weak controller] _, _ in
+        controller?.forEachItemNode({ itemNode in
+            if let itemNode = itemNode as? StatsGraphItemNode {
+                itemNode.resetInteraction()
+            }
+        })
+    }
+    controller.didDisappear = { [weak controller] _ in
+        controller?.clearItemNodesHighlight(animated: true)
+    }
+    openPeerImpl = { [weak controller] peer in
+        if let navigationController = controller?.navigationController as? NavigationController {
+            let _ = (context.account.postbox.loadedPeerWithId(peer.id)
+            |> take(1)
+            |> deliverOnMainQueue).start(next: { peer in
+                if let controller = context.sharedContext.makePeerInfoController(context: context, updatedPresentationData: nil, peer: peer, mode: .generic, avatarInitiallyExpanded: false, fromChat: false, requestsContext: nil) {
+                    navigationController.pushViewController(controller)
+                }
+            })
+        }
+    }
+    openPeerHistoryImpl = { [weak controller] participantPeerId in
+        if let navigationController = controller?.navigationController as? NavigationController {
+            let _ = (context.engine.data.get(
+                TelegramEngine.EngineData.Item.Peer.Peer(id: peerId),
+                TelegramEngine.EngineData.Item.Peer.Peer(id: participantPeerId)
+            )
+            |> deliverOnMainQueue).start(next: { chatPeer, peer in
+                guard let chatPeer, let peer else {
+                    return
+                }
+                context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, chatController: nil, context: context, chatLocation: .peer(chatPeer), subject: nil, botStart: nil, updateTextInputState: nil, keepStack: .always, useExisting: false, purposefulAction: nil, scrollToEndIfExists: false, activateMessageSearch: (.member(peer._asPeer()), ""), animated: true))
+            })
+        }
+    }
+    openPeerAdminActionsImpl = { [weak controller] participantPeerId in
+        if let navigationController = controller?.navigationController as? NavigationController {
+            let _ = (context.account.postbox.loadedPeerWithId(peerId)
+            |> take(1)
+            |> deliverOnMainQueue).start(next: { peer in
+                let controller = context.sharedContext.makeChatRecentActionsController(context: context, peer: peer, adminPeerId: participantPeerId, starsState: nil)
+                navigationController.pushViewController(controller)
+            })
+        }
+    }
+    promotePeerImpl = { [weak controller] participantPeerId in
+        if let navigationController = controller?.navigationController as? NavigationController {
+            let _ = (context.engine.peers.fetchChannelParticipant(peerId: peerId, participantId: participantPeerId)
+            |> take(1)
+            |> deliverOnMainQueue).start(next: { participant in
+                if let participant = participant, let controller = context.sharedContext.makeChannelAdminController(context: context, peerId: peerId, adminId: participantPeerId, initialParticipant: participant) {
+                    navigationController.pushViewController(controller)
+                }
+            })
+        }
+    }
+    return controller
+}

submodules/StatisticsUI/Sources/MessageStatsController.swift

@@ -0,0 +1,563 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import AsyncDisplayKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import TelegramStringFormatting
+import ItemListUI
+import ItemListPeerItem
+import PresentationDataUtils
+import AccountContext
+import PresentationDataUtils
+import AppBundle
+import GraphUI
+import StoryContainerScreen
+import ContextUI
+
+private final class MessageStatsControllerArguments {
+    let context: AccountContext
+    let loadDetailedGraph: (StatsGraph, Int64) -> Signal<StatsGraph?, NoError>
+    let openMessage: (EngineMessage.Id) -> Void
+    let openStory: (EnginePeer.Id, EngineStoryItem, UIView) -> Void
+    let storyContextAction: (EnginePeer.Id, ASDisplayNode, ContextGesture?, Bool) -> Void
+    
+    init(context: AccountContext, loadDetailedGraph: @escaping (StatsGraph, Int64) -> Signal<StatsGraph?, NoError>, openMessage: @escaping (EngineMessage.Id) -> Void, openStory: @escaping (EnginePeer.Id, EngineStoryItem, UIView) -> Void, storyContextAction: @escaping (EnginePeer.Id, ASDisplayNode, ContextGesture?, Bool) -> Void) {
+        self.context = context
+        self.loadDetailedGraph = loadDetailedGraph
+        self.openMessage = openMessage
+        self.openStory = openStory
+        self.storyContextAction = storyContextAction
+    }
+}
+
+private enum StatsSection: Int32 {
+    case overview
+    case interactions
+    case reactions
+    case publicForwards
+}
+
+private enum StatsEntry: ItemListNodeEntry {
+    case overviewTitle(PresentationTheme, String)
+    case overview(PresentationTheme, PostStats, EngineStoryItem.Views?, Int32?)
+    
+    case interactionsTitle(PresentationTheme, String)
+    case interactionsGraph(PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsGraph, ChartType, Bool)
+    
+    case reactionsTitle(PresentationTheme, String)
+    case reactionsGraph(PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsGraph, ChartType, Bool)
+    
+    case publicForwardsTitle(PresentationTheme, String)
+    case publicForward(Int32, PresentationTheme, PresentationStrings, PresentationDateTimeFormat, StatsPostItem)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .overviewTitle, .overview:
+                return StatsSection.overview.rawValue
+            case .interactionsTitle, .interactionsGraph:
+                return StatsSection.interactions.rawValue
+            case .reactionsTitle, .reactionsGraph:
+                return StatsSection.reactions.rawValue
+            case .publicForwardsTitle, .publicForward:
+                return StatsSection.publicForwards.rawValue
+        }
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .overviewTitle:
+                return 0
+            case .overview:
+                return 1
+            case .interactionsTitle:
+                return 2
+            case .interactionsGraph:
+                return 3
+            case .reactionsTitle:
+                return 4
+            case .reactionsGraph:
+                return 5
+            case .publicForwardsTitle:
+                return 6
+            case let .publicForward(index, _, _, _, _):
+                return 7 + index
+        }
+    }
+    
+    static func ==(lhs: StatsEntry, rhs: StatsEntry) -> Bool {
+        switch lhs {
+            case let .overviewTitle(lhsTheme, lhsText):
+                if case let .overviewTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText{
+                    return true
+                } else {
+                    return false
+                }
+            case let .overview(lhsTheme, lhsStats, lhsViews, lhsPublicShares):
+                if case let .overview(rhsTheme, rhsStats, rhsViews, rhsPublicShares) = rhs, lhsTheme === rhsTheme, lhsViews == rhsViews, lhsPublicShares == rhsPublicShares {
+                    if let lhsMessageStats = lhsStats as? MessageStats, let rhsMessageStats = rhsStats as? MessageStats {
+                        return lhsMessageStats == rhsMessageStats
+                    } else if let lhsStoryStats = lhsStats as? StoryStats, let rhsStoryStats = rhsStats as? StoryStats {
+                        return lhsStoryStats == rhsStoryStats
+                    } else {
+                        return false
+                    }
+                } else {
+                    return false
+                }
+            case let .interactionsTitle(lhsTheme, lhsText):
+                if case let .interactionsTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .interactionsGraph(lhsTheme, lhsStrings, lhsDateTimeFormat, lhsGraph, lhsType, lhsNoInitialZoom):
+                if case let .interactionsGraph(rhsTheme, rhsStrings, rhsDateTimeFormat, rhsGraph, rhsType, rhsNoInitialZoom) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsGraph == rhsGraph, lhsType == rhsType, lhsNoInitialZoom == rhsNoInitialZoom {
+                    return true
+                } else {
+                    return false
+                }
+            case let .reactionsTitle(lhsTheme, lhsText):
+                if case let .reactionsTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .reactionsGraph(lhsTheme, lhsStrings, lhsDateTimeFormat, lhsGraph, lhsType, lhsNoInitialZoom):
+                if case let .reactionsGraph(rhsTheme, rhsStrings, rhsDateTimeFormat, rhsGraph, rhsType, rhsNoInitialZoom) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsGraph == rhsGraph, lhsType == rhsType, lhsNoInitialZoom == rhsNoInitialZoom {
+                    return true
+                } else {
+                    return false
+                }
+            case let .publicForwardsTitle(lhsTheme, lhsText):
+                if case let .publicForwardsTitle(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .publicForward(lhsIndex, lhsTheme, lhsStrings, lhsDateTimeFormat, lhsPost):
+                if case let .publicForward(rhsIndex, rhsTheme, rhsStrings, rhsDateTimeFormat, rhsPost) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsPost == rhsPost {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: StatsEntry, rhs: StatsEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! MessageStatsControllerArguments
+        switch self {
+            case let .overviewTitle(_, text),
+                 let .interactionsTitle(_, text),
+                 let .reactionsTitle(_, text),
+                 let .publicForwardsTitle(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .overview(_, stats, storyViews, publicShares):
+                return StatsOverviewItem(context: arguments.context, presentationData: presentationData, isGroup: false, stats: stats as? Stats, storyViews: storyViews, publicShares: publicShares, sectionId: self.section, style: .blocks)
+            case let .interactionsGraph(_, _, _, graph, type, noInitialZoom), let .reactionsGraph(_, _, _, graph, type, noInitialZoom):
+                return StatsGraphItem(presentationData: presentationData, graph: graph, type: type, noInitialZoom: noInitialZoom, getDetailsData: { date, completion in
+                    let _ = arguments.loadDetailedGraph(graph, Int64(date.timeIntervalSince1970) * 1000).start(next: { graph in
+                        if let graph = graph, case let .Loaded(_, data) = graph {
+                            completion(data)
+                        }
+                    })
+                }, sectionId: self.section, style: .blocks)
+            case let .publicForward(_, _, _, _, item):
+                var views: Int32 = 0
+                var forwards: Int32 = 0
+                var reactions: Int32 = 0
+            
+                var isStory = false
+                let peer: Peer
+                switch item {
+                case let .message(message):
+                    peer = message.peers[message.id.peerId]!
+                    for attribute in message.attributes {
+                        if let viewsAttribute = attribute as? ViewCountMessageAttribute {
+                            views = Int32(viewsAttribute.count)
+                        } else if let forwardsAttribute = attribute as? ForwardCountMessageAttribute {
+                            forwards = Int32(forwardsAttribute.count)
+                        } else if let reactionsAttribute = attribute as? ReactionsMessageAttribute {
+                            reactions = reactionsAttribute.reactions.reduce(0, { partialResult, reaction in
+                                return partialResult + reaction.count
+                            })
+                        }
+                    }
+                case let .story(peerValue, story):
+                    peer = peerValue._asPeer()
+                    views = Int32(story.views?.seenCount ?? 0)
+                    forwards = Int32(story.views?.forwardCount ?? 0)
+                    reactions = Int32(story.views?.reactedCount ?? 0)
+                    isStory = true
+                }
+                return StatsMessageItem(context: arguments.context, presentationData: presentationData, peer: peer, item: item, views: views, reactions: reactions, forwards: forwards, isPeer: true, sectionId: self.section, style: .blocks, action: {
+                    switch item {
+                    case let .message(message):
+                        arguments.openMessage(message.id)
+                    case .story:
+                        break
+                    }
+                }, openStory: { view in
+                    if case let .story(peer, story) = item {
+                        arguments.openStory(peer.id, story, view)
+                    }
+                }, contextAction: { node, gesture in
+                    arguments.storyContextAction(peer.id, node, gesture, !isStory)
+                })
+        }
+    }
+}
+
+private func messageStatsControllerEntries(data: PostStats?, storyViews: EngineStoryItem.Views?, forwards: StoryStatsPublicForwardsContext.State?, presentationData: PresentationData) -> [StatsEntry] {
+    var entries: [StatsEntry] = []
+    
+    if let data = data {
+        entries.append(.overviewTitle(presentationData.theme, presentationData.strings.Stats_MessageOverview.uppercased()))
+        
+        var publicShares: Int32?
+        if let forwards {
+            publicShares = forwards.count
+        }
+        entries.append(.overview(presentationData.theme, data, storyViews, publicShares))
+        
+        var isStories = false
+        if let _ = data as? StoryStats {
+            isStories = true
+        }
+    
+        if !data.interactionsGraph.isEmpty {
+            entries.append(.interactionsTitle(presentationData.theme, presentationData.strings.Stats_MessageInteractionsTitle.uppercased()))
+            
+            var chartType: ChartType
+            if data.interactionsGraphDelta == 3600 {
+                chartType = .twoAxisHourlyStep
+            } else if data.interactionsGraphDelta == 300 {
+                chartType = .twoAxis5MinStep
+            } else {
+                chartType = .twoAxisStep
+            }
+            
+            entries.append(.interactionsGraph(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, data.interactionsGraph, chartType, isStories))
+        }
+        
+        if !data.reactionsGraph.isEmpty {
+            entries.append(.reactionsTitle(presentationData.theme, presentationData.strings.Stats_MessageReactionsTitle.uppercased()))
+            entries.append(.reactionsGraph(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, data.reactionsGraph, .bars, isStories))
+        }
+
+        if let forwards, !forwards.forwards.isEmpty {
+            entries.append(.publicForwardsTitle(presentationData.theme, presentationData.strings.Stats_MessagePublicForwardsTitle.uppercased()))
+            var index: Int32 = 0
+            for forward in forwards.forwards {
+                switch forward {
+                case let .message(message):
+                    entries.append(.publicForward(index, presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, .message(message._asMessage())))
+                case let .story(peer, story):
+                    entries.append(.publicForward(index, presentationData.theme, presentationData.strings, presentationData.dateTimeFormat, .story(peer, story)))
+                }
+                index += 1
+            }
+        }
+    }
+    
+    return entries
+}
+
+public enum StatsSubject {
+    case message(id: EngineMessage.Id)
+    case story(peerId: EnginePeer.Id, id: Int32, item: EngineStoryItem, fromStory: Bool)
+}
+
+protocol PostStats {
+    var interactionsGraph: StatsGraph { get }
+    var interactionsGraphDelta: Int64 { get }
+    var reactionsGraph: StatsGraph { get }
+}
+
+extension MessageStats: PostStats {
+    
+}
+
+extension StoryStats: PostStats {
+    
+}
+
+public func messageStatsController(context: AccountContext, updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)? = nil, subject: StatsSubject) -> ViewController {
+    var navigateToMessageImpl: ((EngineMessage.Id) -> Void)?
+    
+    let actionsDisposable = DisposableSet()
+    let dataPromise = Promise<PostStats?>(nil)
+    let forwardsPromise = Promise<StoryStatsPublicForwardsContext.State?>(nil)
+    
+    let anyStatsContext: Any
+    let dataSignal: Signal<PostStats?, NoError>
+    var loadDetailedGraphImpl: ((StatsGraph, Int64) -> Signal<StatsGraph?, NoError>)?
+    var openStoryImpl: ((EnginePeer.Id, EngineStoryItem, UIView) -> Void)?
+    var storyContextActionImpl: ((EnginePeer.Id, ASDisplayNode, ContextGesture?, Bool) -> Void)?
+    
+    let forwardsContext: StoryStatsPublicForwardsContext
+    let peerId: EnginePeer.Id
+    var storyItem: EngineStoryItem?
+    switch subject {
+    case let .message(id):
+        peerId = id.peerId
+        let statsContext = MessageStatsContext(account: context.account, messageId: id)
+        loadDetailedGraphImpl = { [weak statsContext] graph, x in
+            return statsContext?.loadDetailedGraph(graph, x: x) ?? .single(nil)
+        }
+        dataSignal = statsContext.state
+        |> map { state in
+            return state.stats
+        }
+        dataPromise.set(.single(nil) |> then(dataSignal))
+        anyStatsContext = statsContext
+        
+        forwardsContext = StoryStatsPublicForwardsContext(account: context.account, subject: .message(messageId: id))
+    case let .story(peerIdValue, id, item, _):
+        peerId = peerIdValue
+        storyItem = item
+        
+        let statsContext = StoryStatsContext(account: context.account, peerId: peerId, storyId: id)
+        loadDetailedGraphImpl = { [weak statsContext] graph, x in
+            return statsContext?.loadDetailedGraph(graph, x: x) ?? .single(nil)
+        }
+        dataSignal = statsContext.state
+        |> map { state in
+            return state.stats
+        }
+        dataPromise.set(.single(nil) |> then(dataSignal))
+        anyStatsContext = statsContext
+                
+        forwardsContext = StoryStatsPublicForwardsContext(account: context.account, subject: .story(peerId: peerId, id: id))
+    }
+    
+    forwardsPromise.set(
+        .single(nil)
+        |> then(
+            forwardsContext.state
+            |> map(Optional.init)
+        )
+    )
+    
+    let arguments = MessageStatsControllerArguments(context: context, loadDetailedGraph: { graph, x -> Signal<StatsGraph?, NoError> in
+        return loadDetailedGraphImpl?(graph, x) ?? .single(nil)
+    }, openMessage: { messageId in
+        navigateToMessageImpl?(messageId)
+    }, openStory: { peerId, story, view in
+        openStoryImpl?(peerId, story, view)
+    }, storyContextAction: { peerId, node, gesture, isMessage in
+        storyContextActionImpl?(peerId, node, gesture, isMessage)
+    })
+    
+    let longLoadingSignal: Signal<Bool, NoError> = .single(false) |> then(.single(true) |> delay(2.0, queue: Queue.mainQueue()))
+    
+    let previousData = Atomic<PostStats?>(value: nil)
+    
+    let iconNodePromise = Promise<ASDisplayNode?>()
+    if case let .story(peerId, id, storyItem, fromStory) = subject, !fromStory {
+        let _ = id
+        iconNodePromise.set(
+            context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: peerId))
+            |> deliverOnMainQueue
+            |> map { peer -> ASDisplayNode? in
+                if let peer = peer?._asPeer() {
+                    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                    return StoryIconNode(context: context, theme: presentationData.theme, peer: peer, storyItem: storyItem)
+                } else {
+                    return nil
+                }
+            }
+        )
+
+    } else {
+        iconNodePromise.set(.single(nil))
+    }
+    
+    let presentationData = updatedPresentationData?.signal ?? context.sharedContext.presentationData
+    let signal = combineLatest(
+        presentationData,
+        dataPromise.get(),
+        forwardsPromise.get(),
+        longLoadingSignal,
+        iconNodePromise.get()
+    )
+    |> deliverOnMainQueue
+    |> map { presentationData, data, forwards, longLoading, iconNode -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        let previous = previousData.swap(data)
+        var emptyStateItem: ItemListControllerEmptyStateItem?
+        if data == nil {
+            if longLoading {
+                emptyStateItem = StatsEmptyStateItem(context: context, theme: presentationData.theme, strings: presentationData.strings)
+            } else {
+                emptyStateItem = ItemListLoadingIndicatorEmptyStateItem(theme: presentationData.theme)
+            }
+        }
+        
+        let title: String
+        var storyViews: EngineStoryItem.Views?
+        switch subject {
+        case .message:
+            title = presentationData.strings.Stats_MessageTitle
+        case let .story(_, _, storyItem, _):
+            title = presentationData.strings.Stats_StoryTitle
+            storyViews = storyItem.views
+        }
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(title), leftNavigationButton: nil, rightNavigationButton: iconNode.flatMap { ItemListNavigationButton(content: .node($0), style: .regular, enabled: true, action: { [weak iconNode] in
+            if let iconNode, let storyItem {
+                openStoryImpl?(peerId, storyItem, iconNode.view)
+            }
+        }) }, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: true)
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: messageStatsControllerEntries(data: data, storyViews: storyViews, forwards: forwards, presentationData: presentationData), style: .blocks, emptyStateItem: emptyStateItem, crossfadeState: previous == nil, animateChanges: false)
+        
+        return (controllerState, (listState, arguments))
+    }
+    |> afterDisposed {
+        actionsDisposable.dispose()
+        let _ = anyStatsContext
+        let _ = forwardsContext
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    controller.contentOffsetChanged = { [weak controller] _, _ in
+        controller?.forEachItemNode({ itemNode in
+            if let itemNode = itemNode as? StatsGraphItemNode {
+                itemNode.resetInteraction()
+            }
+        })
+    }
+    controller.visibleBottomContentOffsetChanged = { [weak forwardsContext] offset in
+        if case let .known(value) = offset, value < 100.0 {
+            forwardsContext?.loadMore()
+        }
+    }
+    controller.didDisappear = { [weak controller] _ in
+        controller?.clearItemNodesHighlight(animated: true)
+    }
+    navigateToMessageImpl = { [weak controller] messageId in
+        let _ = (context.engine.data.get(
+            TelegramEngine.EngineData.Item.Peer.Peer(id: messageId.peerId)
+        )
+        |> deliverOnMainQueue).start(next: { peer in
+            guard let peer = peer else {
+                return
+            }
+            if let navigationController = controller?.navigationController as? NavigationController {
+                context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peer), subject: .message(id: .id(messageId), highlight: ChatControllerSubject.MessageHighlight(quote: nil), timecode: nil, setupReply: false), keepStack: .always, useExisting: false, purposefulAction: {}, peekData: nil))
+            }
+        })
+    }
+    openStoryImpl = { [weak controller] peerId, story, sourceView in
+        let storyContent = SingleStoryContentContextImpl(context: context, storyId: StoryId(peerId: peerId, id: story.id), storyItem: story, readGlobally: false)
+        let _ = (storyContent.state
+        |> take(1)
+        |> deliverOnMainQueue).startStandalone(next: { [weak controller, weak sourceView] _ in
+            guard let controller, let sourceView else {
+                return
+            }
+            let transitionIn = StoryContainerScreen.TransitionIn(
+                sourceView: sourceView,
+                sourceRect: sourceView.bounds,
+                sourceCornerRadius: sourceView.bounds.width * 0.5,
+                sourceIsAvatar: false
+            )
+        
+            let storyContainerScreen = StoryContainerScreen(
+                context: context,
+                content: storyContent,
+                transitionIn: transitionIn,
+                transitionOut: { [weak sourceView] peerId, storyIdValue in
+                    if let sourceView {
+                        let destinationView = sourceView
+                        return StoryContainerScreen.TransitionOut(
+                            destinationView: destinationView,
+                            transitionView: StoryContainerScreen.TransitionView(
+                                makeView: { [weak destinationView] in
+                                    let parentView = UIView()
+                                    if let copyView = destinationView?.snapshotContentTree(unhide: true) {
+                                        parentView.addSubview(copyView)
+                                    }
+                                    return parentView
+                                },
+                                updateView: { copyView, state, transition in
+                                    guard let view = copyView.subviews.first else {
+                                        return
+                                    }
+                                    let size = state.sourceSize.interpolate(to: state.destinationSize, amount: state.progress)
+                                    transition.setPosition(view: view, position: CGPoint(x: size.width * 0.5, y: size.height * 0.5))
+                                    transition.setScale(view: view, scale: size.width / state.destinationSize.width)
+                                },
+                                insertCloneTransitionView: nil
+                            ),
+                            destinationRect: destinationView.bounds,
+                            destinationCornerRadius: destinationView.bounds.width * 0.5,
+                            destinationIsAvatar: false,
+                            completed: { [weak sourceView] in
+                                guard let sourceView else {
+                                    return
+                                }
+                                sourceView.isHidden = false
+                            }
+                        )
+                    } else {
+                        return nil
+                    }
+                }
+            )
+            controller.push(storyContainerScreen)
+        })
+    }
+    storyContextActionImpl = { [weak controller] peerId, sourceNode, gesture, isMessage in
+        guard let controller = controller, let sourceNode = sourceNode as? ContextExtractedContentContainingNode else {
+            return
+        }
+        
+        let presentationData = updatedPresentationData?.initial ?? context.sharedContext.currentPresentationData.with { $0 }
+        
+        var items: [ContextMenuItem] = []
+        
+        let title: String
+        let iconName: String
+        if isMessage {
+            title = presentationData.strings.Conversation_ViewInChannel
+            iconName = "Chat/Context Menu/GoToMessage"
+        } else {
+            if peerId.isGroupOrChannel {
+                title = presentationData.strings.ChatList_ContextOpenChannel
+                iconName = "Chat/Context Menu/Channels"
+            } else {
+                title = presentationData.strings.Conversation_ContextMenuOpenProfile
+                iconName = "Chat/Context Menu/User"
+            }
+        }
+        
+        items.append(.action(ContextMenuActionItem(text: title, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: iconName), color: theme.contextMenu.primaryColor) }, action: { [weak controller] c, _ in
+            c?.dismiss(completion: {
+                let _ = (context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: peerId))
+                |> deliverOnMainQueue).start(next: { peer in
+                    guard let peer = peer, let navigationController = controller?.navigationController as? NavigationController else {
+                        return
+                    }
+                    if case .user = peer {
+                        if let controller = context.sharedContext.makePeerInfoController(context: context, updatedPresentationData: nil, peer: peer._asPeer(), mode: .generic, avatarInitiallyExpanded: peer.largeProfileImage != nil, fromChat: false, requestsContext: nil) {
+                            navigationController.pushViewController(controller)
+                        }
+                    } else {
+                        context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peer), subject: nil))
+                    }
+                })
+            })
+        })))
+        
+        let contextController = ContextController(presentationData: presentationData, source: .extracted(ChannelStatsContextExtractedContentSource(controller: controller, sourceNode: sourceNode, keepInPlace: false)), items: .single(ContextController.Items(content: .list(items))), gesture: gesture)
+        controller.presentInGlobalOverlay(contextController)
+    }
+    return controller
+}

submodules/StatisticsUI/Sources/MonetizationBalanceItem.swift

@@ -0,0 +1,471 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import AccountContext
+import TelegramPresentationData
+import ItemListUI
+import SolidRoundedButtonNode
+import TelegramCore
+import TextFormat
+import ComponentFlow
+import ButtonComponent
+import BundleIconComponent
+import TelegramStringFormatting
+
+final class MonetizationBalanceItem: ListViewItem, ItemListItem {
+    let context: AccountContext
+    let presentationData: ItemListPresentationData
+    let stats: Stats
+    let canWithdraw: Bool
+    let isEnabled: Bool
+    let actionCooldownUntilTimestamp: Int32?
+    let withdrawAction: () -> Void
+    let buyAdsAction: (() -> Void)?
+    let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    
+    init(
+        context: AccountContext,
+        presentationData: ItemListPresentationData,
+        stats: Stats,
+        canWithdraw: Bool,
+        isEnabled: Bool,
+        actionCooldownUntilTimestamp: Int32?,
+        withdrawAction: @escaping () -> Void,
+        buyAdsAction: (() -> Void)?,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle
+    ) {
+        self.context = context
+        self.presentationData = presentationData
+        self.stats = stats
+        self.canWithdraw = canWithdraw
+        self.isEnabled = isEnabled
+        self.actionCooldownUntilTimestamp = actionCooldownUntilTimestamp
+        self.withdrawAction = withdrawAction
+        self.buyAdsAction = buyAdsAction
+        self.sectionId = sectionId
+        self.style = style
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = MonetizationBalanceItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? MonetizationBalanceItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    var selectable: Bool = false
+}
+
+final class MonetizationBalanceItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let iconNode: ASImageNode
+    private let balanceTextNode: TextNode
+    private let valueTextNode: TextNode
+    private var button = ComponentView<Empty>()
+    private var buyButton = ComponentView<Empty>()
+        
+    private let activateArea: AccessibilityAreaNode
+    
+    private var timer: Foundation.Timer?
+    
+    private var item: MonetizationBalanceItem?
+    private var buttonLayout: (isStars: Bool, origin: CGFloat, width: CGFloat, leftInset: CGFloat, rightInset: CGFloat)?
+    
+    override var canBeSelected: Bool {
+        return false
+    }
+    
+    var tag: ItemListItemTag? {
+        return self.item?.tag
+    }
+    
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        self.backgroundNode.backgroundColor = .white
+        
+        self.maskNode = ASImageNode()
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.iconNode = ASImageNode()
+        self.iconNode.isUserInteractionEnabled = false
+        self.iconNode.displaysAsynchronously = false
+        
+        self.balanceTextNode = TextNode()
+        self.balanceTextNode.isUserInteractionEnabled = false
+        self.balanceTextNode.displaysAsynchronously = false
+        
+        self.valueTextNode = TextNode()
+        self.valueTextNode.isUserInteractionEnabled = false
+        self.valueTextNode.displaysAsynchronously = false
+    
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.iconNode)
+        self.addSubnode(self.balanceTextNode)
+        self.addSubnode(self.valueTextNode)
+    }
+    
+    func asyncLayout() -> (_ item: MonetizationBalanceItem, _ params: ListViewItemLayoutParams, _ insets: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        let makeBalanceTextLayout = TextNode.asyncLayout(self.balanceTextNode)
+        let makeValueTextLayout = TextNode.asyncLayout(self.valueTextNode)
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            
+            let leftInset = 16.0 + params.leftInset
+            let rightInset = 16.0 + params.rightInset
+            let constrainedWidth = params.width - leftInset - rightInset
+            
+            let integralFont = Font.with(size: 48.0, design: .round, weight: .semibold)
+            let fractionalFont = Font.with(size: 24.0, design: .round, weight: .semibold)
+            
+            let amountString: NSAttributedString
+            let value: String
+            
+            var isStars = false
+            if let stats = item.stats as? StarsRevenueStats {
+                switch stats.balances.availableBalance.currency {
+                case .ton:
+                    let cryptoValue = formatTonAmountText(stats.balances.availableBalance.amount.value, dateTimeFormat: item.presentationData.dateTimeFormat)
+                    amountString = tonAmountAttributedString(cryptoValue, integralFont: integralFont, fractionalFont: fractionalFont, color: item.presentationData.theme.list.itemPrimaryTextColor, decimalSeparator: item.presentationData.dateTimeFormat.decimalSeparator)
+                    value = stats.balances.availableBalance.amount == StarsAmount.zero ? "" : "~\(formatTonUsdValue(stats.balances.availableBalance.amount.value, rate: stats.usdRate, dateTimeFormat: item.presentationData.dateTimeFormat))"
+                case .stars:
+                    amountString = NSAttributedString(string: presentationStringsFormattedNumber(stats.balances.availableBalance.amount, item.presentationData.dateTimeFormat.groupingSeparator), font: integralFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor)
+                    value = stats.balances.availableBalance.amount == StarsAmount.zero ? "" : "~\(formatTonUsdValue(stats.balances.availableBalance.amount.value, divide: false, rate: stats.usdRate, dateTimeFormat: item.presentationData.dateTimeFormat))"
+                    isStars = true
+                }
+            } else {
+                fatalError()
+            }
+
+            let (balanceLayout, balanceApply) = makeBalanceTextLayout(TextNodeLayoutArguments(attributedString: amountString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .middle, constrainedSize: CGSize(width: constrainedWidth, height: CGFloat.greatestFiniteMagnitude), alignment: .center, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (valueLayout, valueApply) = makeValueTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: value, font: Font.regular(17.0), textColor: item.presentationData.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .middle, constrainedSize: CGSize(width: constrainedWidth, height: CGFloat.greatestFiniteMagnitude), alignment: .center, cutout: nil, insets: UIEdgeInsets()))
+            
+            let verticalInset: CGFloat = 13.0
+            let buttonHeight: CGFloat = 50.0
+            let buttonSpacing: CGFloat = 12.0
+            
+            var height: CGFloat = verticalInset * 2.0 + balanceLayout.size.height
+            if valueLayout.size.height > 0.0 {
+                height += valueLayout.size.height
+            } else {
+                height -= 6.0
+            }
+            if item.canWithdraw {
+                height += buttonHeight + buttonSpacing
+            }
+
+            switch item.style {
+            case .plain:
+                itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                itemSeparatorColor = .clear
+                insets = UIEdgeInsets()
+            case .blocks:
+                itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+                        
+            contentSize = CGSize(width: params.width, height: height)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (ListViewItemNodeLayout(contentSize: contentSize, insets: insets), { [weak self] in
+                if let strongSelf = self {
+                    let themeUpdated = strongSelf.item?.presentationData.theme !== item.presentationData.theme
+                    strongSelf.item = item
+                    
+                    let _ = balanceApply()
+                    let _ = valueApply()
+                    
+                    strongSelf.activateArea.frame = CGRect(origin: CGPoint(x: params.leftInset, y: 0.0), size: CGSize(width: params.width - params.leftInset - params.rightInset, height: layout.contentSize.height))
+                    strongSelf.activateArea.accessibilityTraits = []
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                    }
+                                                            
+                    switch item.style {
+                    case .plain:
+                        if strongSelf.backgroundNode.supernode != nil {
+                            strongSelf.backgroundNode.removeFromSupernode()
+                        }
+                        if strongSelf.topStripeNode.supernode != nil {
+                            strongSelf.topStripeNode.removeFromSupernode()
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                        }
+                        if strongSelf.maskNode.supernode != nil {
+                            strongSelf.maskNode.removeFromSupernode()
+                        }
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: leftInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - leftInset, height: separatorHeight))
+                    case .blocks:
+                        if strongSelf.backgroundNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                        }
+                        if strongSelf.topStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                        }
+                        if strongSelf.maskNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                        }
+                        
+                        let hasCorners = itemListHasRoundedBlockLayout(params)
+                        var hasTopCorners = false
+                        var hasBottomCorners = false
+                        switch neighbors.top {
+                            case .sameSection(false):
+                                strongSelf.topStripeNode.isHidden = true
+                            default:
+                                hasTopCorners = true
+                                strongSelf.topStripeNode.isHidden = hasCorners
+                        }
+                        let bottomStripeInset: CGFloat
+                        switch neighbors.bottom {
+                            case .sameSection(false):
+                                bottomStripeInset = leftInset
+                                strongSelf.bottomStripeNode.isHidden = false
+                            default:
+                                bottomStripeInset = 0.0
+                                hasBottomCorners = true
+                                strongSelf.bottomStripeNode.isHidden = hasCorners
+                        }
+                        
+                        strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners) : nil
+                        
+                        strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                        strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                        strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset, height: separatorHeight))
+                    }
+                    
+                    if themeUpdated {
+                        if isStars {
+                            strongSelf.iconNode.image = UIImage(bundleImageName: "Premium/Stars/BalanceStar")
+                        } else {
+                            strongSelf.iconNode.image = generateTintedImage(image: UIImage(bundleImageName: "Ads/TonBig"), color: item.presentationData.theme.list.itemAccentColor)
+                        }
+                    }
+
+                    var emojiItemSize = CGSize()
+                    if let icon = strongSelf.iconNode.image {
+                        emojiItemSize = icon.size
+                    }
+                                        
+                    let balanceTotalWidth: CGFloat = emojiItemSize.width + balanceLayout.size.width
+                    let balanceTextFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((params.width - balanceTotalWidth) / 2.0) + emojiItemSize.width, y: verticalInset), size: balanceLayout.size)
+                    strongSelf.balanceTextNode.frame = balanceTextFrame
+                    
+                    strongSelf.iconNode.frame = CGRect(origin: CGPoint(x: balanceTextFrame.minX - emojiItemSize.width - 7.0, y: floorToScreenPixels(balanceTextFrame.midY - emojiItemSize.height / 2.0) - 3.0), size: emojiItemSize)
+                    
+                    strongSelf.valueTextNode.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((params.width - valueLayout.size.width) / 2.0), y: balanceTextFrame.maxY - 5.0), size: valueLayout.size)
+                                      
+                    strongSelf.buttonLayout = (isStars: isStars, origin: strongSelf.valueTextNode.frame.maxY + buttonSpacing + 3.0, width: params.width, leftInset: leftInset, rightInset: rightInset)
+                    strongSelf.updateButton()
+                }
+            })
+        }
+    }
+    
+    func updateButton() {
+        guard let item = self.item, let (isStars, origin, width, leftInset, rightInset) = self.buttonLayout else {
+            return
+        }
+        
+        if item.canWithdraw {
+            var remainingCooldownSeconds: Int32 = 0
+            if let cooldownUntilTimestamp = item.actionCooldownUntilTimestamp {
+                remainingCooldownSeconds = cooldownUntilTimestamp - Int32(Date().timeIntervalSince1970)
+                remainingCooldownSeconds = max(0, remainingCooldownSeconds)
+            }
+            
+            if remainingCooldownSeconds > 0 {
+                if self.timer == nil {
+                    self.timer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true, block: { [weak self] _ in
+                        guard let self else {
+                            return
+                        }
+                        self.updateButton()
+                    })
+                }
+            } else {
+                if let timer = self.timer {
+                    self.timer = nil
+                    timer.invalidate()
+                }
+            }
+                        
+            var actionTitle = isStars ? item.presentationData.strings.Monetization_BalanceStarsWithdraw : item.presentationData.strings.Monetization_BalanceWithdraw
+            var withdrawWidth = width - leftInset - rightInset
+            if let _ = item.buyAdsAction {
+                withdrawWidth = (withdrawWidth - 10.0) / 2.0
+                actionTitle = item.presentationData.strings.Monetization_BalanceStarsWithdrawShort
+            }
+            
+            let content: AnyComponentWithIdentity<Empty>
+            if remainingCooldownSeconds > 0 {
+                content = AnyComponentWithIdentity(id: AnyHashable(1 as Int), component: AnyComponent(
+                    VStack([
+                        AnyComponentWithIdentity(id: AnyHashable(1 as Int), component: AnyComponent(Text(text: actionTitle, font: Font.semibold(17.0), color: item.presentationData.theme.list.itemCheckColors.foregroundColor))),
+                        AnyComponentWithIdentity(id: AnyHashable(0 as Int), component: AnyComponent(HStack([
+                            AnyComponentWithIdentity(id: 1, component: AnyComponent(BundleIconComponent(name: "Chat List/StatusLockIcon", tintColor: item.presentationData.theme.list.itemCheckColors.fillColor.mixedWith(item.presentationData.theme.list.itemCheckColors.foregroundColor, alpha: 0.7)))),
+                            AnyComponentWithIdentity(id: 0, component: AnyComponent(Text(text: stringForRemainingTime(remainingCooldownSeconds), font: Font.with(size: 11.0, weight: .medium, traits: [.monospacedNumbers]), color: item.presentationData.theme.list.itemCheckColors.fillColor.mixedWith(item.presentationData.theme.list.itemCheckColors.foregroundColor, alpha: 0.7))))
+                        ], spacing: 3.0)))
+                    ], spacing: 1.0)
+                ))
+            } else {
+                content = AnyComponentWithIdentity(id: AnyHashable(0 as Int), component: AnyComponent(Text(text: actionTitle, font: Font.semibold(17.0), color: item.presentationData.theme.list.itemCheckColors.foregroundColor)))
+            }
+                        
+            let buttonSize = self.button.update(
+                transition: .immediate,
+                component: AnyComponent(ButtonComponent(
+                    background: ButtonComponent.Background(
+                        color: item.presentationData.theme.list.itemCheckColors.fillColor,
+                        foreground: item.presentationData.theme.list.itemCheckColors.foregroundColor,
+                        pressedColor: item.presentationData.theme.list.itemCheckColors.fillColor.withMultipliedAlpha(0.8)
+                    ),
+                    content: content,
+                    isEnabled: item.isEnabled,
+                    allowActionWhenDisabled: false,
+                    displaysProgress: false,
+                    action: { [weak self] in
+                        guard let self, let item = self.item, item.isEnabled else {
+                            return
+                        }
+                        item.withdrawAction()
+                    }
+                )),
+                environment: {},
+                containerSize: CGSize(width: withdrawWidth, height: 50.0)
+            )
+            if let buttonView = self.button.view {
+                if buttonView.superview == nil {
+                    self.view.addSubview(buttonView)
+                }
+                let buttonFrame = CGRect(origin: CGPoint(x: leftInset, y: origin), size: buttonSize)
+                buttonView.frame = buttonFrame
+            }
+            
+            if let _ = item.buyAdsAction {
+                let buyButtonSize = self.buyButton.update(
+                    transition: .immediate,
+                    component: AnyComponent(ButtonComponent(
+                        background: ButtonComponent.Background(
+                            color: item.presentationData.theme.list.itemCheckColors.fillColor,
+                            foreground: item.presentationData.theme.list.itemCheckColors.foregroundColor,
+                            pressedColor: item.presentationData.theme.list.itemCheckColors.fillColor.withMultipliedAlpha(0.8)
+                        ),
+                        content: AnyComponentWithIdentity(id: AnyHashable(0 as Int), component: AnyComponent(Text(text: item.presentationData.strings.Monetization_BalanceStarsBuyAds, font: Font.semibold(17.0), color: item.presentationData.theme.list.itemCheckColors.foregroundColor))),
+                        isEnabled: true,
+                        allowActionWhenDisabled: false,
+                        displaysProgress: false,
+                        action: { [weak self] in
+                            guard let self, let item = self.item else {
+                                return
+                            }
+                            item.buyAdsAction?()
+                        }
+                    )),
+                    environment: {},
+                    containerSize: CGSize(width: withdrawWidth, height: 50.0)
+                )
+                if let buttonView = self.buyButton.view {
+                    if buttonView.superview == nil {
+                        self.view.addSubview(buttonView)
+                    }
+                    let buttonFrame = CGRect(origin: CGPoint(x: leftInset + withdrawWidth + 10.0, y: origin), size: buyButtonSize)
+                    buttonView.frame = buttonFrame
+                }
+            } else if let buttonView = self.buyButton.view {
+                buttonView.removeFromSuperview()
+            }
+        } else if let buttonView = self.button.view {
+            buttonView.removeFromSuperview()
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateAdded(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}
+
+func stringForRemainingTime(_ duration: Int32) -> String {
+    let hours = duration / 3600
+    let minutes = duration / 60 % 60
+    let seconds = duration % 60
+    let durationString: String
+    if hours > 0 {
+        durationString = String(format: "%d:%02d", hours, minutes)
+    } else {
+        durationString = String(format: "%02d:%02d", minutes, seconds)
+    }
+    return durationString
+}

submodules/StatisticsUI/Sources/MonetizationIntroScreen.swift

@@ -0,0 +1,629 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import SwiftSignalKit
+import TelegramCore
+import Markdown
+import TextFormat
+import TelegramPresentationData
+import ViewControllerComponent
+import SheetComponent
+import BundleIconComponent
+import BalancedTextComponent
+import MultilineTextComponent
+import SolidRoundedButtonComponent
+import LottieComponent
+import AccountContext
+
+private final class SheetContent: CombinedComponent {
+    typealias EnvironmentType = ViewControllerComponentContainer.Environment
+    
+    let context: AccountContext
+    let mode: MonetizationIntroScreen.Mode
+    let openMore: () -> Void
+    let dismiss: () -> Void
+    
+    init(
+        context: AccountContext,
+        mode: MonetizationIntroScreen.Mode,
+        openMore: @escaping () -> Void,
+        dismiss: @escaping () -> Void
+    ) {
+        self.context = context
+        self.mode = mode
+        self.openMore = openMore
+        self.dismiss = dismiss
+    }
+    
+    static func ==(lhs: SheetContent, rhs: SheetContent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.mode != rhs.mode {
+            return false
+        }
+        return true
+    }
+    
+    final class State: ComponentState {
+        var cachedIconImage: (UIImage, PresentationTheme)?
+        var cachedChevronImage: (UIImage, PresentationTheme)?
+        var cachedTonImage: (UIImage, PresentationTheme)?
+        
+        let playOnce =  ActionSlot<Void>()
+        private var didPlayAnimation = false
+                
+        func playAnimationIfNeeded() {
+            guard !self.didPlayAnimation else {
+                return
+            }
+            self.didPlayAnimation = true
+            self.playOnce.invoke(Void())
+        }
+    }
+    
+    func makeState() -> State {
+        return State()
+    }
+    
+    static var body: Body {
+        let iconBackground = Child(Image.self)
+        let icon = Child(BundleIconComponent.self)
+        
+        let title = Child(BalancedTextComponent.self)
+        let list = Child(List<Empty>.self)
+        let actionButton = Child(SolidRoundedButtonComponent.self)
+        
+        let infoBackground = Child(RoundedRectangle.self)
+        let infoTitle = Child(MultilineTextComponent.self)
+        let infoText = Child(MultilineTextComponent.self)
+        
+        let spaceRegex = try? NSRegularExpression(pattern: "\\[(.*?)\\]", options: [])
+        
+        return { context in
+            let environment = context.environment[EnvironmentType.self]
+            let component = context.component
+            let state = context.state
+            
+            let theme = environment.theme
+            let strings = environment.strings
+            
+            let sideInset: CGFloat = 16.0 + environment.safeInsets.left
+            let textSideInset: CGFloat = 30.0 + environment.safeInsets.left
+            
+            let titleFont = Font.semibold(20.0)
+            let textFont = Font.regular(15.0)
+            
+            let textColor = theme.actionSheet.primaryTextColor
+            let secondaryTextColor = theme.actionSheet.secondaryTextColor
+            let linkColor = theme.actionSheet.controlAccentColor
+            
+            let markdownAttributes = MarkdownAttributes(body: MarkdownAttributeSet(font: textFont, textColor: textColor), bold: MarkdownAttributeSet(font: textFont, textColor: textColor), link: MarkdownAttributeSet(font: textFont, textColor: linkColor), linkAttribute: { contents in
+                return (TelegramTextAttributes.URL, contents)
+            })
+                        
+            let spacing: CGFloat = 16.0
+            var contentSize = CGSize(width: context.availableSize.width, height: 32.0)
+                                    
+            let iconSize = CGSize(width: 90.0, height: 90.0)
+            let gradientImage: UIImage
+                            
+            if let (current, currentTheme) = state.cachedIconImage, currentTheme === theme {
+                gradientImage = current
+            } else {
+                gradientImage = generateGradientFilledCircleImage(diameter: iconSize.width, colors: [
+                    UIColor(rgb: 0x4bbb45).cgColor,
+                    UIColor(rgb: 0x9ad164).cgColor
+                ])!
+                context.state.cachedIconImage = (gradientImage, theme)
+            }
+            
+            let iconBackground = iconBackground.update(
+                component: Image(image: gradientImage),
+                availableSize: iconSize,
+                transition: .immediate
+            )
+            context.add(iconBackground
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + iconBackground.size.height / 2.0))
+            )
+            
+            let icon = icon.update(
+                component: BundleIconComponent(name: "Ads/MonetizationLogo", tintColor: theme.list.itemCheckColors.foregroundColor),
+                availableSize: CGSize(width: 90, height: 90),
+                transition: .immediate
+            )
+            
+            context.add(icon
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + iconBackground.size.height / 2.0))
+            )
+            contentSize.height += iconSize.height
+            contentSize.height += spacing + 5.0
+            
+            let title = title.update(
+                component: BalancedTextComponent(
+                    text: .plain(NSAttributedString(string: component.mode == .bot ?  strings.Monetization_Intro_Bot_Title : strings.Monetization_Intro_Title, font: titleFont, textColor: textColor)),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 0,
+                    lineSpacing: 0.1
+                ),
+                availableSize: CGSize(width: context.availableSize.width - textSideInset * 2.0, height: context.availableSize.height),
+                transition: .immediate
+            )
+            context.add(title
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + title.size.height / 2.0))
+            )
+            contentSize.height += title.size.height
+            contentSize.height += spacing - 2.0
+            
+            var items: [AnyComponentWithIdentity<Empty>] = []
+            items.append(
+                AnyComponentWithIdentity(
+                    id: "ads",
+                    component: AnyComponent(ParagraphComponent(
+                        title: strings.Monetization_Intro_Ads_Title,
+                        titleColor: textColor,
+                        text: component.mode == .bot ? strings.Monetization_Intro_Bot_Ads_Text : strings.Monetization_Intro_Ads_Text,
+                        textColor: secondaryTextColor,
+                        iconName: "Ads/Ads",
+                        iconColor: linkColor
+                    ))
+                )
+            )
+            items.append(
+                AnyComponentWithIdentity(
+                    id: "split",
+                    component: AnyComponent(ParagraphComponent(
+                        title: strings.Monetization_Intro_Split_Title,
+                        titleColor: textColor,
+                        text: strings.Monetization_Intro_Split_Text,
+                        textColor: secondaryTextColor,
+                        iconName: "Ads/Split",
+                        iconColor: linkColor
+                    ))
+                )
+            )
+            items.append(
+                AnyComponentWithIdentity(
+                    id: "withdrawal",
+                    component: AnyComponent(ParagraphComponent(
+                        title: strings.Monetization_Intro_Withdrawal_Title,
+                        titleColor: textColor,
+                        text: strings.Monetization_Intro_Withdrawal_Text,
+                        textColor: secondaryTextColor,
+                        iconName: "Ads/Withdrawal",
+                        iconColor: linkColor
+                    ))
+                )
+            )
+            
+            let list = list.update(
+                component: List(items),
+                availableSize: CGSize(width: context.availableSize.width - sideInset, height: 10000.0),
+                transition: context.transition
+            )
+            context.add(list
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + list.size.height / 2.0))
+            )
+            contentSize.height += list.size.height
+            contentSize.height += spacing - 13.0
+            
+            if state.cachedTonImage == nil || state.cachedTonImage?.1 !== environment.theme {
+                state.cachedTonImage = (generateTintedImage(image: UIImage(bundleImageName: "Ads/TonAbout"), color: linkColor)!, theme)
+            }
+            
+            let infoTitleString = strings.Monetization_Intro_Info_Title.replacingOccurrences(of: "#", with: " # ")
+            let infoTitleAttributedString = NSMutableAttributedString(string: infoTitleString, font: titleFont, textColor: textColor)
+            let range = (infoTitleAttributedString.string as NSString).range(of: "#")
+            if range.location != NSNotFound, let icon = state.cachedTonImage?.0 {
+                infoTitleAttributedString.addAttribute(.attachment, value: icon, range: range)
+                infoTitleAttributedString.addAttribute(.foregroundColor, value: linkColor, range: range)
+                infoTitleAttributedString.addAttribute(.baselineOffset, value: 1.0, range: range)
+            }
+            let infoTitle = infoTitle.update(
+                component: MultilineTextComponent(
+                    text: .plain(infoTitleAttributedString),
+                    horizontalAlignment: .center
+                ),
+                availableSize: CGSize(width: context.availableSize.width - textSideInset * 2.0, height: context.availableSize.height),
+                transition: .immediate
+            )
+            
+            if state.cachedChevronImage == nil || state.cachedChevronImage?.1 !== environment.theme {
+                state.cachedChevronImage = (generateTintedImage(image: UIImage(bundleImageName: "Settings/TextArrowRight"), color: linkColor)!, theme)
+            }
+            
+            let presentationData = component.context.sharedContext.currentPresentationData.with { $0 }
+            var infoString = strings.Monetization_Intro_Info_Text
+            if let spaceRegex {
+                let nsRange = NSRange(infoString.startIndex..., in: infoString)
+                let matches = spaceRegex.matches(in: infoString, options: [], range: nsRange)
+                var modifiedString = infoString
+                
+                for match in matches.reversed() {
+                    let matchRange = Range(match.range, in: infoString)!
+                    let matchedSubstring = String(infoString[matchRange])
+                    let replacedSubstring = matchedSubstring.replacingOccurrences(of: " ", with: "\u{00A0}")
+                    modifiedString.replaceSubrange(matchRange, with: replacedSubstring)
+                }
+                infoString = modifiedString
+            }
+
+            let infoAttributedString = parseMarkdownIntoAttributedString(infoString, attributes: markdownAttributes).mutableCopy() as! NSMutableAttributedString
+            if let range = infoAttributedString.string.range(of: ">"), let chevronImage = state.cachedChevronImage?.0 {
+                infoAttributedString.addAttribute(.attachment, value: chevronImage, range: NSRange(range, in: infoAttributedString.string))
+                infoAttributedString.addAttribute(.baselineOffset, value: 1.0, range: NSRange(range, in: infoAttributedString.string))
+            }
+            let infoText = infoText.update(
+                component: MultilineTextComponent(
+                    text: .plain(infoAttributedString),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 0,
+                    lineSpacing: 0.2,
+                    highlightColor: linkColor.withMultipliedAlpha(0.1),
+                    highlightInset: UIEdgeInsets(top: 0.0, left: 0.0, bottom: 0.0, right: -8.0),
+                    highlightAction: { attributes in
+                        if let _ = attributes[NSAttributedString.Key(rawValue: TelegramTextAttributes.URL)] {
+                            return NSAttributedString.Key(rawValue: TelegramTextAttributes.URL)
+                        } else {
+                            return nil
+                        }
+                    },
+                    tapAction: { _, _ in
+                        component.context.sharedContext.openExternalUrl(context: component.context, urlContext: .generic, url: strings.Monetization_Intro_Info_Text_URL, forceExternal: true, presentationData: presentationData, navigationController: nil, dismissInput: {})
+                    }
+                ),
+                availableSize: CGSize(width: context.availableSize.width - (textSideInset + sideInset - 2.0) * 2.0, height: context.availableSize.height),
+                transition: .immediate
+            )
+            
+            let infoPadding: CGFloat = 17.0
+            let infoSpacing: CGFloat = 12.0
+            let totalInfoHeight = infoPadding + infoTitle.size.height + infoSpacing + infoText.size.height + infoPadding
+            
+            let infoBackground = infoBackground.update(
+                component: RoundedRectangle(
+                    color: theme.list.blocksBackgroundColor,
+                    cornerRadius: 10.0
+                ),
+                availableSize: CGSize(width: context.availableSize.width - sideInset * 2.0, height: totalInfoHeight),
+                transition: .immediate
+            )
+            context.add(infoBackground
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + infoBackground.size.height / 2.0))
+            )
+            contentSize.height += infoPadding
+            
+            context.add(infoTitle
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + infoTitle.size.height / 2.0))
+            )
+            contentSize.height += infoTitle.size.height
+            contentSize.height += infoSpacing
+            
+            context.add(infoText
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + infoText.size.height / 2.0))
+            )
+            contentSize.height += infoText.size.height
+            contentSize.height += infoPadding
+            contentSize.height += spacing
+            
+            let actionButton = actionButton.update(
+                component: SolidRoundedButtonComponent(
+                    title: strings.Monetization_Intro_Understood,
+                    theme: SolidRoundedButtonComponent.Theme(
+                        backgroundColor: theme.list.itemCheckColors.fillColor,
+                        backgroundColors: [],
+                        foregroundColor: theme.list.itemCheckColors.foregroundColor
+                    ),
+                    font: .bold,
+                    fontSize: 17.0,
+                    height: 50.0,
+                    cornerRadius: 10.0,
+                    gloss: false,
+                    iconName: nil,
+                    animationName: nil,
+                    iconPosition: .left,
+                    action: {
+                        component.dismiss()
+                    }
+                ),
+                availableSize: CGSize(width: context.availableSize.width - sideInset * 2.0, height: 50.0),
+                transition: context.transition
+            )
+            context.add(actionButton
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + actionButton.size.height / 2.0))
+            )
+            contentSize.height += actionButton.size.height
+            contentSize.height += 22.0
+                        
+            contentSize.height += environment.safeInsets.bottom
+            
+            state.playAnimationIfNeeded()
+            
+            return contentSize
+        }
+    }
+}
+
+private final class SheetContainerComponent: CombinedComponent {
+    typealias EnvironmentType = ViewControllerComponentContainer.Environment
+    
+    let context: AccountContext
+    let mode: MonetizationIntroScreen.Mode
+    let openMore: () -> Void
+    
+    init(
+        context: AccountContext,
+        mode: MonetizationIntroScreen.Mode,
+        openMore: @escaping () -> Void
+    ) {
+        self.context = context
+        self.mode = mode
+        self.openMore = openMore
+    }
+    
+    static func ==(lhs: SheetContainerComponent, rhs: SheetContainerComponent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.mode != rhs.mode {
+            return false
+        }
+        return true
+    }
+    
+    static var body: Body {
+        let sheet = Child(SheetComponent<EnvironmentType>.self)
+        let animateOut = StoredActionSlot(Action<Void>.self)
+        
+        let sheetExternalState = SheetComponent<EnvironmentType>.ExternalState()
+        
+        return { context in
+            let environment = context.environment[EnvironmentType.self]
+            
+            let controller = environment.controller
+            
+            let sheet = sheet.update(
+                component: SheetComponent<EnvironmentType>(
+                    content: AnyComponent<EnvironmentType>(SheetContent(
+                        context: context.component.context,
+                        mode: context.component.mode,
+                        openMore: context.component.openMore,
+                        dismiss: {
+                            animateOut.invoke(Action { _ in
+                                if let controller = controller() {
+                                    controller.dismiss(completion: nil)
+                                }
+                            })
+                        }
+                    )),
+                    backgroundColor: .color(environment.theme.actionSheet.opaqueItemBackgroundColor),
+                    followContentSizeChanges: true,
+                    externalState: sheetExternalState,
+                    animateOut: animateOut
+                ),
+                environment: {
+                    environment
+                    SheetComponentEnvironment(
+                        isDisplaying: environment.value.isVisible,
+                        isCentered: environment.metrics.widthClass == .regular,
+                        hasInputHeight: !environment.inputHeight.isZero,
+                        regularMetricsSize: CGSize(width: 430.0, height: 900.0),
+                        dismiss: { animated in
+                            if animated {
+                                animateOut.invoke(Action { _ in
+                                    if let controller = controller() {
+                                        controller.dismiss(completion: nil)
+                                    }
+                                })
+                            } else {
+                                if let controller = controller() {
+                                    controller.dismiss(completion: nil)
+                                }
+                            }
+                        }
+                    )
+                },
+                availableSize: context.availableSize,
+                transition: context.transition
+            )
+            
+            context.add(sheet
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: context.availableSize.height / 2.0))
+            )
+            
+            if let controller = controller(), !controller.automaticallyControlPresentationContextLayout {
+                let layout = ContainerViewLayout(
+                    size: context.availableSize,
+                    metrics: environment.metrics,
+                    deviceMetrics: environment.deviceMetrics,
+                    intrinsicInsets: UIEdgeInsets(top: 0.0, left: 0.0, bottom: max(environment.safeInsets.bottom, sheetExternalState.contentHeight), right: 0.0),
+                    safeInsets: UIEdgeInsets(top: 0.0, left: environment.safeInsets.left, bottom: 0.0, right: environment.safeInsets.right),
+                    additionalInsets: .zero,
+                    statusBarHeight: environment.statusBarHeight,
+                    inputHeight: nil,
+                    inputHeightIsInteractivellyChanging: false,
+                    inVoiceOver: false
+                )
+                controller.presentationContext.containerLayoutUpdated(layout, transition: context.transition.containedViewLayoutTransition)
+            }
+            
+            return context.availableSize
+        }
+    }
+}
+
+
+final class MonetizationIntroScreen: ViewControllerComponentContainer {
+    private let context: AccountContext
+    private var openMore: (() -> Void)?
+    
+    enum Mode: Equatable {
+        case channel
+        case bot
+    }
+    
+    init(
+        context: AccountContext,
+        mode: Mode,
+        openMore: @escaping () -> Void
+    ) {
+        self.context = context
+        self.openMore = openMore
+                
+        super.init(
+            context: context,
+            component: SheetContainerComponent(
+                context: context,
+                mode: mode,
+                openMore: openMore
+            ),
+            navigationBarAppearance: .none,
+            statusBarStyle: .ignore,
+            theme: .default
+        )
+        
+        self.navigationPresentation = .flatModal
+    }
+    
+    required public init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        
+        self.view.disablesInteractiveModalDismiss = true
+    }
+    
+    func dismissAnimated() {
+        if let view = self.node.hostView.findTaggedView(tag: SheetComponent<ViewControllerComponentContainer.Environment>.View.Tag()) as? SheetComponent<ViewControllerComponentContainer.Environment>.View {
+            view.dismissAnimated()
+        }
+    }
+}
+
+private final class ParagraphComponent: CombinedComponent {
+    let title: String
+    let titleColor: UIColor
+    let text: String
+    let textColor: UIColor
+    let iconName: String
+    let iconColor: UIColor
+    
+    public init(
+        title: String,
+        titleColor: UIColor,
+        text: String,
+        textColor: UIColor,
+        iconName: String,
+        iconColor: UIColor
+    ) {
+        self.title = title
+        self.titleColor = titleColor
+        self.text = text
+        self.textColor = textColor
+        self.iconName = iconName
+        self.iconColor = iconColor
+    }
+    
+    static func ==(lhs: ParagraphComponent, rhs: ParagraphComponent) -> Bool {
+        if lhs.title != rhs.title {
+            return false
+        }
+        if lhs.titleColor != rhs.titleColor {
+            return false
+        }
+        if lhs.text != rhs.text {
+            return false
+        }
+        if lhs.textColor != rhs.textColor {
+            return false
+        }
+        if lhs.iconName != rhs.iconName {
+            return false
+        }
+        if lhs.iconColor != rhs.iconColor {
+            return false
+        }
+        return true
+    }
+    
+    static var body: Body {
+        let title = Child(MultilineTextComponent.self)
+        let text = Child(MultilineTextComponent.self)
+        let icon = Child(BundleIconComponent.self)
+        
+        return { context in
+            let component = context.component
+            
+            let leftInset: CGFloat = 64.0
+            let rightInset: CGFloat = 32.0
+            let textSideInset: CGFloat = leftInset + 8.0
+            let spacing: CGFloat = 5.0
+            
+            let textTopInset: CGFloat = 9.0
+            
+            let title = title.update(
+                component: MultilineTextComponent(
+                    text: .plain(NSAttributedString(
+                        string: component.title,
+                        font: Font.semibold(15.0),
+                        textColor: component.titleColor,
+                        paragraphAlignment: .natural
+                    )),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 1
+                ),
+                availableSize: CGSize(width: context.availableSize.width - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude),
+                transition: .immediate
+            )
+            
+            let textFont = Font.regular(15.0)
+            let boldTextFont = Font.semibold(15.0)
+            let textColor = component.textColor
+            let markdownAttributes = MarkdownAttributes(
+                body: MarkdownAttributeSet(font: textFont, textColor: textColor),
+                bold: MarkdownAttributeSet(font: boldTextFont, textColor: textColor),
+                link: MarkdownAttributeSet(font: textFont, textColor: textColor),
+                linkAttribute: { _ in
+                    return nil
+                }
+            )
+                        
+            let text = text.update(
+                component: MultilineTextComponent(
+                    text: .markdown(text: component.text, attributes: markdownAttributes),
+                    horizontalAlignment: .natural,
+                    maximumNumberOfLines: 0,
+                    lineSpacing: 0.2
+                ),
+                availableSize: CGSize(width: context.availableSize.width - leftInset - rightInset, height: context.availableSize.height),
+                transition: .immediate
+            )
+            
+            let icon = icon.update(
+                component: BundleIconComponent(
+                    name: component.iconName,
+                    tintColor: component.iconColor
+                ),
+                availableSize: CGSize(width: context.availableSize.width, height: context.availableSize.height),
+                transition: .immediate
+            )
+         
+            context.add(title
+                .position(CGPoint(x: textSideInset + title.size.width / 2.0, y: textTopInset + title.size.height / 2.0))
+            )
+            
+            context.add(text
+                .position(CGPoint(x: textSideInset + text.size.width / 2.0, y: textTopInset + title.size.height + spacing + text.size.height / 2.0))
+            )
+            
+            context.add(icon
+                .position(CGPoint(x: 47.0, y: textTopInset + 18.0))
+            )
+        
+            return CGSize(width: context.availableSize.width, height: textTopInset + title.size.height + text.size.height + 18.0)
+        }
+    }
+}

submodules/StatisticsUI/Sources/RevenueWithdrawalController.swift

@@ -0,0 +1,112 @@
+import Foundation
+import Display
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import PresentationDataUtils
+import AccountContext
+import PasswordSetupUI
+import Markdown
+import OwnershipTransferController
+
+func confirmRevenueWithdrawalController(context: AccountContext, updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)? = nil, peerId: EnginePeer.Id, present: @escaping (ViewController, Any?) -> Void, completion: @escaping (String) -> Void) -> ViewController {
+    let presentationData = updatedPresentationData?.initial ?? context.sharedContext.currentPresentationData.with { $0 }
+    
+    var dismissImpl: (() -> Void)?
+    var proceedImpl: (() -> Void)?
+    
+    let disposable = MetaDisposable()
+    
+    let contentNode = ChannelOwnershipTransferAlertContentNode(theme: AlertControllerTheme(presentationData: presentationData), ptheme: presentationData.theme, strings: presentationData.strings, title: presentationData.strings.Monetization_Withdraw_EnterPassword_Title, text: presentationData.strings.Monetization_Withdraw_EnterPassword_Text, actions: [TextAlertAction(type: .genericAction, title: presentationData.strings.Common_Cancel, action: {
+        dismissImpl?()
+    }), TextAlertAction(type: .defaultAction, title: presentationData.strings.Monetization_Withdraw_EnterPassword_Done, action: {
+        proceedImpl?()
+    })])
+    
+    contentNode.complete = {
+        proceedImpl?()
+    }
+    
+    let controller = AlertController(theme: AlertControllerTheme(presentationData: presentationData), contentNode: contentNode)
+    let presentationDataDisposable = (updatedPresentationData?.signal ?? context.sharedContext.presentationData).start(next: { [weak controller, weak contentNode] presentationData in
+        controller?.theme = AlertControllerTheme(presentationData: presentationData)
+        contentNode?.theme = presentationData.theme
+    })
+    controller.dismissed = { _ in
+        presentationDataDisposable.dispose()
+        disposable.dispose()
+    }
+    dismissImpl = { [weak controller, weak contentNode] in
+        contentNode?.dismissInput()
+        controller?.dismissAnimated()
+    }
+    proceedImpl = { [weak contentNode] in
+        guard let contentNode = contentNode else {
+            return
+        }
+        contentNode.updateIsChecking(true)
+        
+        let signal = context.engine.peers.requestStarsRevenueWithdrawalUrl(peerId: peerId, ton: true, amount: nil, password: contentNode.password)
+        disposable.set((signal |> deliverOnMainQueue).start(next: { url in
+            dismissImpl?()
+            completion(url)
+        }, error: { [weak contentNode] error in
+            var errorTextAndActions: (String, [TextAlertAction])?
+            switch error {
+                case .invalidPassword:
+                    contentNode?.animateError()
+                case .limitExceeded:
+                    errorTextAndActions = (presentationData.strings.TwoStepAuth_FloodError, [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})])
+                default:
+                    errorTextAndActions = (presentationData.strings.Login_UnknownError, [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})])
+            }
+            contentNode?.updateIsChecking(false)
+            
+            if let (text, actions) = errorTextAndActions {
+                dismissImpl?()
+                present(textAlertController(context: context, title: nil, text: text, actions: actions), nil)
+            }
+        }))
+    }
+    
+    return controller
+}
+
+
+public func revenueWithdrawalController(context: AccountContext, updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)? = nil, peerId: EnginePeer.Id, initialError: RequestStarsRevenueWithdrawalError, present: @escaping (ViewController, Any?) -> Void, completion: @escaping (String) -> Void) -> ViewController {
+    let presentationData = updatedPresentationData?.initial ?? context.sharedContext.currentPresentationData.with { $0 }
+    let theme = AlertControllerTheme(presentationData: presentationData)
+    
+    var title: NSAttributedString? = NSAttributedString(string: presentationData.strings.OwnershipTransfer_SecurityCheck, font: Font.semibold(presentationData.listsFontSize.itemListBaseFontSize), textColor: theme.primaryColor, paragraphAlignment: .center)
+    
+    var text = presentationData.strings.Monetization_Withdraw_SecurityRequirements
+    let textFontSize = presentationData.listsFontSize.baseDisplaySize * 13.0 / 17.0
+    
+    var actions: [TextAlertAction] = []
+    switch initialError {
+        case .requestPassword:
+            return confirmRevenueWithdrawalController(context: context, updatedPresentationData: updatedPresentationData, peerId: peerId, present: present, completion: completion)
+        case .twoStepAuthTooFresh, .authSessionTooFresh:
+            text = text + presentationData.strings.Monetization_Withdraw_ComeBackLater
+            actions = [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})]
+        case .twoStepAuthMissing:
+            actions = [TextAlertAction(type: .genericAction, title: presentationData.strings.OwnershipTransfer_SetupTwoStepAuth, action: {
+                let controller = SetupTwoStepVerificationController(context: context, initialState: .automatic, stateUpdated: { update, shouldDismiss, controller in
+                    if shouldDismiss {
+                        controller.dismiss()
+                    }
+                })
+                present(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+            }), TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_Cancel, action: {})]
+        default:
+            title = nil
+            text = presentationData.strings.Login_UnknownError
+            actions = [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})]
+    }
+    
+    let body = MarkdownAttributeSet(font: Font.regular(textFontSize), textColor: theme.primaryColor)
+    let bold = MarkdownAttributeSet(font: Font.semibold(textFontSize), textColor: theme.primaryColor)
+    let attributedText = parseMarkdownIntoAttributedString(text, attributes: MarkdownAttributes(body: body, bold: bold, link: body, linkAttribute: { _ in return nil }), textAlignment: .center)
+    
+    return richTextAlertController(context: context, title: title, text: attributedText, actions: actions)
+}

submodules/StatisticsUI/Sources/StarsTransactionItem.swift

@@ -0,0 +1,428 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import AccountContext
+import TelegramPresentationData
+import ItemListUI
+import ComponentFlow
+import ListActionItemComponent
+import MultilineTextComponent
+import TelegramStringFormatting
+import StarsAvatarComponent
+
+final class StarsTransactionItem: ListViewItem, ItemListItem {
+    let context: AccountContext
+    let presentationData: ItemListPresentationData
+    let transaction: StarsContext.State.Transaction
+    let action: () -> Void
+    let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    
+    init(
+        context: AccountContext,
+        presentationData: ItemListPresentationData,
+        transaction: StarsContext.State.Transaction,
+        action: @escaping () -> Void,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle
+    ) {
+        self.context = context
+        self.presentationData = presentationData
+        self.transaction = transaction
+        self.action = action
+        self.sectionId = sectionId
+        self.style = style
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = StarsTransactionItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? StarsTransactionItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    var selectable: Bool = true
+    
+    public func selected(listView: ListView) {
+        listView.clearHighlightAnimated(true)
+        self.action()
+    }
+}
+
+final class StarsTransactionItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let componentView: ComponentView<Empty>
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private var item: StarsTransactionItem?
+    
+    var tag: ItemListItemTag? = nil
+    
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        self.backgroundNode.backgroundColor = .white
+        
+        self.maskNode = ASImageNode()
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        self.componentView = ComponentView<Empty>()
+    
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+    }
+    
+    func asyncLayout() -> (_ item: StarsTransactionItem, _ params: ListViewItemLayoutParams, _ insets: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            
+            let leftInset = 16.0 + params.leftInset
+            
+            let height: CGFloat = 78.0
+
+            switch item.style {
+            case .plain:
+                itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                itemSeparatorColor = .clear
+                insets = UIEdgeInsets()
+            case .blocks:
+                itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+                        
+            contentSize = CGSize(width: params.width, height: height)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (ListViewItemNodeLayout(contentSize: contentSize, insets: insets), { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                        
+                    strongSelf.activateArea.frame = CGRect(origin: CGPoint(x: params.leftInset, y: 0.0), size: CGSize(width: params.width - params.leftInset - params.rightInset, height: layout.contentSize.height))
+                    strongSelf.activateArea.accessibilityTraits = []
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.presentationData.theme.list.itemHighlightedBackgroundColor
+                    }
+                                                            
+                    switch item.style {
+                    case .plain:
+                        if strongSelf.backgroundNode.supernode != nil {
+                            strongSelf.backgroundNode.removeFromSupernode()
+                        }
+                        if strongSelf.topStripeNode.supernode != nil {
+                            strongSelf.topStripeNode.removeFromSupernode()
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                        }
+                        if strongSelf.maskNode.supernode != nil {
+                            strongSelf.maskNode.removeFromSupernode()
+                        }
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: leftInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - leftInset, height: separatorHeight))
+                    case .blocks:
+                        if strongSelf.backgroundNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                        }
+                        if strongSelf.topStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                        }
+                        if strongSelf.maskNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                        }
+                        
+                        let hasCorners = itemListHasRoundedBlockLayout(params)
+                        var hasTopCorners = false
+                        var hasBottomCorners = false
+                        switch neighbors.top {
+                            case .sameSection(false):
+                                strongSelf.topStripeNode.isHidden = true
+                            default:
+                                hasTopCorners = true
+                                strongSelf.topStripeNode.isHidden = hasCorners
+                        }
+                        let bottomStripeInset: CGFloat
+                        switch neighbors.bottom {
+                            case .sameSection(false):
+                                bottomStripeInset = leftInset
+                                strongSelf.bottomStripeNode.isHidden = false
+                            default:
+                                bottomStripeInset = 0.0
+                                hasBottomCorners = true
+                                strongSelf.bottomStripeNode.isHidden = hasCorners
+                        }
+                        
+                        strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners) : nil
+                        
+                        strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                        strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                        strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset, height: separatorHeight))
+                    }
+                    
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: layout.contentSize.height + UIScreenPixel + UIScreenPixel))
+                    
+                    let fontBaseDisplaySize = 17.0
+                    
+                    let itemTitle: String
+                    let itemSubtitle: String?
+                    var itemDate: String
+                    switch item.transaction.peer {
+                    case let .peer(peer):
+                        if item.transaction.flags.contains(.isPaidMessage) {
+                            itemTitle = peer.displayTitle(strings: item.presentationData.strings, displayOrder: .firstLast)
+                            itemSubtitle = item.presentationData.strings.Stars_Intro_Transaction_PaidMessage(item.transaction.paidMessageCount ?? 1)
+                        } else if !item.transaction.media.isEmpty {
+                            itemTitle = item.presentationData.strings.Stars_Intro_Transaction_MediaPurchase
+                            itemSubtitle = peer.displayTitle(strings: item.presentationData.strings, displayOrder: .firstLast)
+                        } else if let title = item.transaction.title {
+                            itemTitle = title
+                            itemSubtitle = peer.displayTitle(strings: item.presentationData.strings, displayOrder: .firstLast)
+                        } else {
+                            if item.transaction.flags.contains(.isReaction) {
+                                itemSubtitle = item.presentationData.strings.Stars_Intro_Transaction_Reaction_Title
+                            } else if let _ = item.transaction.subscriptionPeriod {
+                                itemSubtitle = item.presentationData.strings.Stars_Intro_Transaction_SubscriptionFee_Title
+                            } else {
+                                itemSubtitle = nil
+                            }
+                            itemTitle = peer.displayTitle(strings: item.presentationData.strings, displayOrder: .firstLast)
+                        }
+                    case .appStore:
+                        itemTitle = item.presentationData.strings.Stars_Intro_Transaction_AppleTopUp_Title
+                        itemSubtitle = item.presentationData.strings.Stars_Intro_Transaction_AppleTopUp_Subtitle
+                    case .playMarket:
+                        itemTitle = item.presentationData.strings.Stars_Intro_Transaction_GoogleTopUp_Title
+                        itemSubtitle = item.presentationData.strings.Stars_Intro_Transaction_GoogleTopUp_Subtitle
+                    case .fragment:
+                        itemTitle = item.presentationData.strings.Stars_Intro_Transaction_FragmentWithdrawal_Title
+                        itemSubtitle = item.presentationData.strings.Stars_Intro_Transaction_FragmentWithdrawal_Subtitle
+                    case .premiumBot:
+                        itemTitle = item.presentationData.strings.Stars_Intro_Transaction_PremiumBotTopUp_Title
+                        itemSubtitle = item.presentationData.strings.Stars_Intro_Transaction_PremiumBotTopUp_Subtitle
+                    case .ads:
+                        itemTitle = item.presentationData.strings.Stars_Intro_Transaction_TelegramAds_Title
+                        itemSubtitle = item.presentationData.strings.Stars_Intro_Transaction_TelegramAds_Subtitle
+                    case .apiLimitExtension:
+                        itemTitle = item.presentationData.strings.Stars_Intro_Transaction_TelegramBotApi_Title
+                        if let floodskipNumber = item.transaction.floodskipNumber {
+                            itemSubtitle = item.presentationData.strings.Stars_Intro_Transaction_TelegramBotApi_Messages(floodskipNumber)
+                        } else {
+                            itemSubtitle = nil
+                        }
+                    case .unsupported:
+                        itemTitle = item.presentationData.strings.Stars_Intro_Transaction_Unsupported_Title
+                        itemSubtitle = nil
+                    }
+                    
+                    let itemLabel: NSAttributedString
+                    let formattedLabel = formatCurrencyAmountText(item.transaction.count, dateTimeFormat: item.presentationData.dateTimeFormat, showPlus: true)
+                    
+                    let smallLabelFont = Font.with(size: floor(fontBaseDisplaySize / 17.0 * 13.0))
+                    let labelFont = Font.medium(fontBaseDisplaySize)
+                    let labelColor = formattedLabel.hasPrefix("-") ? item.presentationData.theme.list.itemDestructiveColor : item.presentationData.theme.list.itemDisclosureActions.constructive.fillColor
+                    itemLabel = tonAmountAttributedString(formattedLabel, integralFont: labelFont, fractionalFont: smallLabelFont, color: labelColor, decimalSeparator: item.presentationData.dateTimeFormat.decimalSeparator)
+                    
+                    var itemDateColor = item.presentationData.theme.list.itemSecondaryTextColor
+                    itemDate = stringForMediumCompactDate(timestamp: item.transaction.date, strings: item.presentationData.strings, dateTimeFormat: item.presentationData.dateTimeFormat)
+                    if item.transaction.flags.contains(.isRefund) {
+                        itemDate += " – \(item.presentationData.strings.Stars_Intro_Transaction_Refund)"
+                    } else if item.transaction.flags.contains(.isPending) {
+                        itemDate += " – \(item.presentationData.strings.Monetization_Transaction_Pending)"
+                    } else if item.transaction.flags.contains(.isFailed) {
+                        itemDate += " – \(item.presentationData.strings.Monetization_Transaction_Failed)"
+                        itemDateColor = item.presentationData.theme.list.itemDestructiveColor
+                    }
+                    
+                    var titleComponents: [AnyComponentWithIdentity<Empty>] = []
+                    titleComponents.append(
+                        AnyComponentWithIdentity(id: AnyHashable(0), component: AnyComponent(MultilineTextComponent(
+                            text: .plain(NSAttributedString(
+                                string: itemTitle,
+                                font: Font.semibold(fontBaseDisplaySize),
+                                textColor: item.presentationData.theme.list.itemPrimaryTextColor
+                            )),
+                            maximumNumberOfLines: 1
+                        )))
+                    )
+                    if let itemSubtitle {
+                        titleComponents.append(
+                            AnyComponentWithIdentity(id: AnyHashable(1), component: AnyComponent(MultilineTextComponent(
+                                text: .plain(NSAttributedString(
+                                    string: itemSubtitle,
+                                    font: Font.regular(fontBaseDisplaySize * 16.0 / 17.0),
+                                    textColor: item.presentationData.theme.list.itemPrimaryTextColor
+                                )),
+                                maximumNumberOfLines: 1
+                            )))
+                        )
+                    }
+                    titleComponents.append(
+                        AnyComponentWithIdentity(id: AnyHashable(2), component: AnyComponent(MultilineTextComponent(
+                            text: .plain(NSAttributedString(
+                                string: itemDate,
+                                font: Font.regular(floor(fontBaseDisplaySize * 14.0 / 17.0)),
+                                textColor: itemDateColor
+                            )),
+                            maximumNumberOfLines: 1
+                        )))
+                    )
+                    
+                    let itemIconName: String
+                    let itemIconColor: UIColor?
+                    switch item.transaction.count.currency {
+                    case .stars:
+                        itemIconName = "Premium/Stars/StarMedium"
+                        itemIconColor = nil
+                    case .ton:
+                        itemIconName = "Ads/TonAbout"
+                        itemIconColor = labelColor
+                    }
+                    
+                    let itemSize = strongSelf.componentView.update(
+                        transition: .immediate,
+                        component: AnyComponent(ListActionItemComponent(
+                            theme: item.presentationData.theme,
+                            title: AnyComponent(VStack(titleComponents, alignment: .left, spacing: 2.0)),
+                            contentInsets: UIEdgeInsets(top: 9.0, left: 0.0, bottom: 8.0, right: 0.0),
+                            leftIcon: .custom(AnyComponentWithIdentity(id: "avatar", component: AnyComponent(StarsAvatarComponent(context: item.context, theme: item.presentationData.theme, peer: .transactionPeer(item.transaction.peer), photo: nil, media: [], gift: nil, backgroundColor: item.presentationData.theme.list.itemBlocksBackgroundColor))), false),
+                            icon: nil,
+                            accessory: .custom(ListActionItemComponent.CustomAccessory(component: AnyComponentWithIdentity(id: "label", component: AnyComponent(StarsLabelComponent(text: itemLabel, iconName: itemIconName, iconColor: itemIconColor))), insets: UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 16.0))),
+                            action: { [weak self] _ in
+                                guard let self, let item = self.item else {
+                                    return
+                                }
+                                if !item.transaction.flags.contains(.isLocal) {
+                                    item.action()
+                                }
+                            }
+                        )),
+                        environment: {},
+                        containerSize: CGSize(width: params.width - params.leftInset - params.rightInset, height: height)
+                    )
+                    let itemFrame = CGRect(origin: CGPoint(x: params.leftInset, y: 0.0), size: itemSize)
+                    if let itemComponentView = strongSelf.componentView.view {
+                        if itemComponentView.superview == nil {
+                            strongSelf.view.addSubview(itemComponentView)
+                        }
+                        itemComponentView.isUserInteractionEnabled = false
+                        itemComponentView.frame = itemFrame
+                    }
+                }
+            })
+        }
+    }
+    
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                        })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateAdded(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}

submodules/StatisticsUI/Sources/StatsEmptyItem.swift

@@ -0,0 +1,108 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import AnimatedStickerNode
+import TelegramAnimatedStickerNode
+import AccountContext
+
+final class StatsEmptyStateItem: ItemListControllerEmptyStateItem {
+    let context: AccountContext
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    
+    init(context: AccountContext, theme: PresentationTheme, strings: PresentationStrings) {
+        self.context = context
+        self.theme = theme
+        self.strings = strings
+    }
+    
+    func isEqual(to: ItemListControllerEmptyStateItem) -> Bool {
+        if let item = to as? StatsEmptyStateItem {
+            return self.theme === item.theme && self.strings === item.strings
+        } else {
+            return false
+        }
+    }
+    
+    func node(current: ItemListControllerEmptyStateItemNode?) -> ItemListControllerEmptyStateItemNode {
+        if let current = current as? StatsEmptyStateItemNode {
+            current.item = self
+            return current
+        } else {
+            return StatsEmptyStateItemNode(item: self)
+        }
+    }
+}
+
+final class StatsEmptyStateItemNode: ItemListControllerEmptyStateItemNode {
+    private var animationNode: AnimatedStickerNode
+    private let titleNode: ASTextNode
+    private let textNode: ASTextNode
+    private var validLayout: (ContainerViewLayout, CGFloat)?
+    
+    var item: StatsEmptyStateItem {
+        didSet {
+            self.updateThemeAndStrings(theme: self.item.theme, strings: self.item.strings)
+            if let (layout, navigationHeight) = self.validLayout {
+                self.updateLayout(layout: layout, navigationBarHeight: navigationHeight, transition: .immediate)
+            }
+        }
+    }
+    
+    init(item: StatsEmptyStateItem) {
+        self.item = item
+        
+        self.animationNode = DefaultAnimatedStickerNodeImpl()
+        self.animationNode.setup(source: AnimatedStickerNodeLocalFileSource(name: "Charts"), width: 192, height: 192, playbackMode: .loop, mode: .direct(cachePathPrefix: nil))
+        self.animationNode.visibility = true
+        
+        self.titleNode = ASTextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        
+        self.textNode = ASTextNode()
+        self.textNode.isUserInteractionEnabled = false
+        
+        super.init()
+        
+        self.addSubnode(self.animationNode)
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.textNode)
+        
+        self.updateThemeAndStrings(theme: self.item.theme, strings: self.item.strings)
+    }
+    
+    private func updateThemeAndStrings(theme: PresentationTheme, strings: PresentationStrings) {
+        self.titleNode.attributedText = NSAttributedString(string: strings.Stats_LoadingTitle, font: Font.bold(17.0), textColor: theme.list.freeTextColor, paragraphAlignment: .center)
+        self.textNode.attributedText = NSAttributedString(string: strings.Stats_LoadingText, font: Font.regular(14.0), textColor: theme.list.freeTextColor, paragraphAlignment: .center)
+    }
+    
+    override func updateLayout(layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
+        self.validLayout = (layout, navigationBarHeight)
+        var insets = layout.insets(options: [])
+        insets.top += navigationBarHeight
+        
+        let imageSpacing: CGFloat = 20.0
+        let textSpacing: CGFloat = 8.0
+    
+        let imageSize = CGSize(width: 96.0, height: 96.0)
+        let imageHeight = layout.size.width < layout.size.height ? imageSize.height + imageSpacing : 0.0
+        
+        self.animationNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - imageSize.width) / 2.0), y: -10.0), size: imageSize)
+        self.animationNode.updateLayout(size: imageSize)
+        
+        let titleSize = self.titleNode.measure(CGSize(width: layout.size.width - layout.safeInsets.left - layout.safeInsets.right - layout.intrinsicInsets.left - layout.intrinsicInsets.right - 50.0, height: max(1.0, layout.size.height - insets.top - insets.bottom)))
+        let textSize = self.textNode.measure(CGSize(width: layout.size.width - layout.safeInsets.left - layout.safeInsets.right - layout.intrinsicInsets.left - layout.intrinsicInsets.right - 50.0, height: max(1.0, layout.size.height - insets.top - insets.bottom)))
+        
+        let totalHeight = imageHeight + titleSize.height + textSpacing + textSize.height
+        let topOffset = insets.top + floor((layout.size.height - insets.top - insets.bottom - totalHeight) / 2.0)
+        
+        transition.updateAlpha(node: self.animationNode, alpha: imageHeight > 0.0 ? 1.0 : 0.0)
+        transition.updateFrame(node: self.animationNode, frame: CGRect(origin: CGPoint(x: floor((layout.size.width - imageSize.width) / 2.0), y: topOffset), size: imageSize))
+        transition.updateFrame(node: self.titleNode, frame: CGRect(origin: CGPoint(x: floor((layout.size.width - titleSize.width - layout.safeInsets.left - layout.safeInsets.right - layout.intrinsicInsets.left - layout.intrinsicInsets.right) / 2.0), y: topOffset + imageHeight), size: titleSize))
+        transition.updateFrame(node: self.textNode, frame: CGRect(origin: CGPoint(x: floor((layout.size.width - textSize.width - layout.safeInsets.left - layout.safeInsets.right - layout.intrinsicInsets.left - layout.intrinsicInsets.right) / 2.0), y: self.titleNode.frame.maxY + textSpacing), size: textSize))
+    }
+}

submodules/StatisticsUI/Sources/StatsGraphItem.swift

@@ -0,0 +1,337 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import GraphCore
+import GraphUI
+import ActivityIndicator
+import ListItemComponentAdaptor
+
+public final class StatsGraphItem: ListViewItem, ItemListItem, ListItemComponentAdaptor.ItemGenerator {
+    let presentationData: ItemListPresentationData
+    let graph: StatsGraph
+    let type: ChartType
+    let noInitialZoom: Bool
+    let conversionRate: Double
+    let getDetailsData: ((Date, @escaping (String?) -> Void) -> Void)?
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    
+    public init(presentationData: ItemListPresentationData, graph: StatsGraph, type: ChartType, noInitialZoom: Bool = false, conversionRate: Double = 1.0, getDetailsData: ((Date, @escaping (String?) -> Void) -> Void)? = nil, sectionId: ItemListSectionId, style: ItemListStyle) {
+        self.presentationData = presentationData
+        self.graph = graph
+        self.type = type
+        self.noInitialZoom = noInitialZoom
+        self.conversionRate = conversionRate
+        self.getDetailsData = getDetailsData
+        self.sectionId = sectionId
+        self.style = style
+    }
+    
+    public func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = StatsGraphItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    public func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? StatsGraphItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public func item() -> ListViewItem {
+        return self
+    }
+    
+    public static func ==(lhs: StatsGraphItem, rhs: StatsGraphItem) -> Bool {
+        if lhs.presentationData !== rhs.presentationData {
+            return false
+        }
+        if lhs.graph != rhs.graph {
+            return false
+        }
+        if lhs.type != rhs.type {
+            return false
+        }
+        if lhs.noInitialZoom != rhs.noInitialZoom {
+            return false
+        }
+        if lhs.conversionRate != rhs.conversionRate {
+            return false
+        }
+        if lhs.sectionId != rhs.sectionId {
+            return false
+        }
+        if lhs.style != rhs.style {
+            return false
+        }
+        return true
+    }
+    
+    public var selectable: Bool = false
+}
+
+public final class StatsGraphItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    private let chartContainerNode: ASDisplayNode
+    
+    let chartNode: ChartNode
+    private let activityIndicator: ActivityIndicator
+    
+    private var item: StatsGraphItem?
+    private var visibilityHeight: CGFloat?
+        
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        self.backgroundNode.backgroundColor = .white
+        
+        self.maskNode = ASImageNode()
+        self.maskNode.isUserInteractionEnabled = false
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.chartContainerNode = ASDisplayNode()
+        self.chartContainerNode.clipsToBounds = true
+        self.chartContainerNode.isUserInteractionEnabled = true
+        
+        self.chartNode = ChartNode()
+        self.activityIndicator = ActivityIndicator(type: ActivityIndicatorType.custom(.black, 16.0, 2.0, false))
+        self.activityIndicator.isHidden = true
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.chartContainerNode.addSubnode(self.chartNode)
+        self.chartContainerNode.addSubnode(self.activityIndicator)
+    }
+    
+    public override func didLoad() {
+        super.didLoad()
+    
+        self.view.interactiveTransitionGestureRecognizerTest = { point -> Bool in
+            return point.x > 30.0 || (point.y > 310.0 && point.y < 355.0)
+        }
+    }
+    
+    public func resetInteraction() {
+        self.chartNode.resetInteraction()
+    }
+    
+    func asyncLayout() -> (_ item: StatsGraphItem, _ params: ListViewItemLayoutParams, _ insets: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        let currentVisibilityHeight = self.visibilityHeight
+        
+        return { item, params, neighbors in
+            let leftInset = params.leftInset
+            let rightInset: CGFloat = params.rightInset
+            var updatedTheme: PresentationTheme?
+            var updatedGraph: StatsGraph?
+            var updatedController: BaseChartController?
+            
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            
+            if currentItem?.graph != item.graph {
+                updatedGraph = item.graph
+                if case let .Loaded(_, data) = updatedGraph {
+                    updatedController = createChartController(data, type: item.type, rate: item.conversionRate, getDetailsData: { [weak self] date, completion in
+                        if let strongSelf = self, let item = strongSelf.item {
+                            item.getDetailsData?(date, completion)
+                        }
+                    })
+                }
+            }
+            
+            var contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            
+            switch item.style {
+                case .plain:
+                    itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                    itemSeparatorColor = item.presentationData.theme.list.itemPlainSeparatorColor
+                    contentSize = CGSize(width: params.width, height: 361.0)
+                    insets = itemListNeighborsPlainInsets(neighbors)
+                case .blocks:
+                    itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                    itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                    contentSize = CGSize(width: params.width, height: 361.0)
+                    insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+                
+            var visibilityHeight = currentVisibilityHeight
+            if let updatedController = updatedController {
+                var height: CGFloat = 0.0
+                var items: [ChartVisibilityItem] = []
+                for item in updatedController.actualChartsCollection.chartValues {
+                    items.append(ChartVisibilityItem(title: item.name, color: .black))
+                }
+                if items.count > 1 {
+                    height = calculateVisiblityHeight(width: params.width - params.leftInset - params.rightInset, items: items)
+                }
+                if item.type == .hourlyStep {
+                    height -= 82.0
+                }
+                visibilityHeight = height
+            }
+            if let visibilityHeight = visibilityHeight {
+                contentSize.height += visibilityHeight
+            }
+            contentSize.height += 7.0
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            return (ListViewItemNodeLayout(contentSize: contentSize, insets: insets), { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.visibilityHeight = visibilityHeight
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                    }
+                                                            
+                    switch item.style {
+                    case .plain:
+                        if strongSelf.backgroundNode.supernode != nil {
+                            strongSelf.backgroundNode.removeFromSupernode()
+                        }
+                        if strongSelf.topStripeNode.supernode != nil {
+                            strongSelf.topStripeNode.removeFromSupernode()
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                        }
+                        if strongSelf.maskNode.supernode != nil {
+                            strongSelf.maskNode.removeFromSupernode()
+                        }
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: leftInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - leftInset, height: separatorHeight))
+                    case .blocks:
+                        if strongSelf.backgroundNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                        }
+                        if strongSelf.chartContainerNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.chartContainerNode, at: 1)
+                        }
+                        if strongSelf.topStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.topStripeNode, at: 2)
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 3)
+                        }
+                        if strongSelf.maskNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.maskNode, at: 4)
+                        }
+                        let hasCorners = itemListHasRoundedBlockLayout(params)
+                        var hasTopCorners = false
+                        var hasBottomCorners = false
+                        switch neighbors.top {
+                            case .sameSection(false):
+                                strongSelf.topStripeNode.isHidden = true
+                            default:
+                                hasTopCorners = true
+                                strongSelf.topStripeNode.isHidden = hasCorners
+                        }
+                        let bottomStripeInset: CGFloat
+                        switch neighbors.bottom {
+                            case .sameSection(false):
+                                bottomStripeInset = leftInset
+                                strongSelf.bottomStripeNode.isHidden = false
+                            default:
+                                bottomStripeInset = 0.0
+                                hasBottomCorners = true
+                                strongSelf.bottomStripeNode.isHidden = hasCorners
+                        }
+                        
+                        strongSelf.chartContainerNode.frame = CGRect(origin: CGPoint(x: leftInset, y: 0.0), size: CGSize(width: layout.size.width - leftInset - rightInset, height: contentSize.height))
+                        strongSelf.chartNode.frame = CGRect(origin: CGPoint(x: 0.0, y: item.type == .hourlyStep ? -40.0 : 0.0), size: CGSize(width: layout.size.width - leftInset - rightInset, height: 750.0))
+                        strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners) : nil
+                        
+                        strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                        strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                        strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset, height: separatorHeight))
+                        
+                        strongSelf.activityIndicator.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - 16.0) / 2.0), y: floor((layout.size.height - 16.0) / 2.0)), size: CGSize(width: 16.0, height: 16.0))
+                    }
+                    
+                    strongSelf.activityIndicator.type = .custom(item.presentationData.theme.list.itemSecondaryTextColor, 16.0, 2.0, false)
+                    
+                    if let updatedTheme = updatedTheme {
+                        strongSelf.chartNode.setup(
+                            theme: ChartTheme(presentationTheme: updatedTheme),
+                            strings: ChartStrings(
+                                zoomOut: item.presentationData.strings.Stats_ZoomOut,
+                                total: item.presentationData.strings.Stats_Total,
+                                revenueInTon: item.presentationData.strings.Stats_RevenueInTon,
+                                revenueInStars: item.presentationData.strings.Stats_RevenueInStars,
+                                revenueInUsd: item.presentationData.strings.Stats_RevenueInUsd
+                            )
+                        )
+                    }
+                    
+                    if let updatedGraph = updatedGraph {
+                        if case .Loaded = updatedGraph, let updatedController = updatedController {
+                            strongSelf.chartNode.setup(controller: updatedController, noInitialZoom: item.noInitialZoom)
+                            strongSelf.activityIndicator.isHidden = true
+                            strongSelf.chartNode.isHidden = false
+                        } else if case .OnDemand = updatedGraph {
+                            strongSelf.activityIndicator.isHidden = false
+                            strongSelf.chartNode.isHidden = true
+                        }
+                    }
+                }
+            })
+        }
+    }
+    
+    public override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    public override func animateAdded(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+    }
+    
+    public override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}
+

submodules/StatisticsUI/Sources/StatsMessageItem.swift

@@ -0,0 +1,769 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import ComponentFlow
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AccountContext
+import TelegramPresentationData
+import TelegramStringFormatting
+import ItemListUI
+import PresentationDataUtils
+import PhotoResources
+import AvatarStoryIndicatorComponent
+import AvatarNode
+
+public class StatsMessageItem: ListViewItem, ItemListItem {
+    let context: AccountContext
+    let presentationData: ItemListPresentationData
+    let peer: Peer
+    let item: StatsPostItem
+    let views: Int32
+    let reactions: Int32
+    let forwards: Int32
+    let isPeer: Bool
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let action: (() -> Void)?
+    let openStory: (UIView) -> Void
+    let contextAction: ((ASDisplayNode, ContextGesture?) -> Void)?
+    
+    init(context: AccountContext, presentationData: ItemListPresentationData, peer: Peer, item: StatsPostItem, views: Int32, reactions: Int32, forwards: Int32, isPeer: Bool = false, sectionId: ItemListSectionId, style: ItemListStyle, action: (() -> Void)?, openStory: @escaping (UIView) -> Void, contextAction: ((ASDisplayNode, ContextGesture?) -> Void)?) {
+        self.context = context
+        self.presentationData = presentationData
+        self.peer = peer
+        self.item = item
+        self.views = views
+        self.reactions = reactions
+        self.forwards = forwards
+        self.isPeer = isPeer
+        self.sectionId = sectionId
+        self.style = style
+        self.action = action
+        self.openStory = openStory
+        self.contextAction = contextAction
+    }
+    
+    public func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = StatsMessageItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    public func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? StatsMessageItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = true
+    
+    public func selected(listView: ListView){
+        listView.clearHighlightAnimated(true)
+    }
+}
+
+
+private let badgeFont = Font.regular(15.0)
+
+final class StatsMessageItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    let contextSourceNode: ContextExtractedContentContainingNode
+    private let containerNode: ContextControllerSourceNode
+    private let extractedBackgroundImageNode: ASImageNode
+    private let offsetContainerNode: ASDisplayNode
+    private let countersContainerNode: ASDisplayNode
+    
+    private var extractedRect: CGRect?
+    private var nonExtractedRect: CGRect?
+    
+    var avatarNode: AvatarNode?
+    let contentImageNode: TransformImageNode
+    var storyIndicator: ComponentView<Empty>?
+    var storyButton: HighlightTrackingButton?
+    
+    let titleNode: TextNode
+    let labelNode: TextNode
+    let viewsNode: TextNode
+    
+    let reactionsIconNode: ASImageNode
+    let reactionsNode: TextNode
+    let forwardsIconNode: ASImageNode
+    let forwardsNode: TextNode
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private var item: StatsMessageItem?
+    private var contentImageMedia: Media?
+    
+    override public var canBeSelected: Bool {
+        return true
+    }
+    
+    public var tag: ItemListItemTag? {
+        return self.item?.tag
+    }
+    
+    public init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        self.backgroundNode.backgroundColor = .white
+        
+        self.maskNode = ASImageNode()
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.contextSourceNode = ContextExtractedContentContainingNode()
+        self.containerNode = ContextControllerSourceNode()
+        
+        self.extractedBackgroundImageNode = ASImageNode()
+        self.extractedBackgroundImageNode.displaysAsynchronously = false
+        self.extractedBackgroundImageNode.alpha = 0.0
+        
+        self.contentImageNode = TransformImageNode()
+        self.contentImageNode.isLayerBacked = false
+        
+        self.offsetContainerNode = ASDisplayNode()
+        self.countersContainerNode = ASDisplayNode()
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        
+        self.labelNode = TextNode()
+        self.labelNode.isUserInteractionEnabled = false
+
+        self.viewsNode = TextNode()
+        self.viewsNode.isUserInteractionEnabled = false
+        
+        self.forwardsNode = TextNode()
+        self.forwardsNode.isUserInteractionEnabled = false
+        
+        self.forwardsIconNode = ASImageNode()
+        self.forwardsIconNode.displaysAsynchronously = false
+        
+        self.reactionsNode = TextNode()
+        self.reactionsNode.isUserInteractionEnabled = false
+        
+        self.reactionsIconNode = ASImageNode()
+        self.reactionsIconNode.displaysAsynchronously = false
+        
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.containerNode.addSubnode(self.contextSourceNode)
+        self.containerNode.targetNodeForActivationProgress = self.contextSourceNode.contentNode
+        self.addSubnode(self.containerNode)
+        
+        self.contextSourceNode.contentNode.addSubnode(self.extractedBackgroundImageNode)
+        self.contextSourceNode.contentNode.addSubnode(self.offsetContainerNode)
+        self.contextSourceNode.contentNode.addSubnode(self.countersContainerNode)
+        
+        self.offsetContainerNode.addSubnode(self.contentImageNode)
+        self.offsetContainerNode.addSubnode(self.titleNode)
+        self.offsetContainerNode.addSubnode(self.labelNode)
+        self.countersContainerNode.addSubnode(self.viewsNode)
+        self.countersContainerNode.addSubnode(self.forwardsNode)
+        self.countersContainerNode.addSubnode(self.forwardsIconNode)
+        self.countersContainerNode.addSubnode(self.reactionsNode)
+        self.countersContainerNode.addSubnode(self.reactionsIconNode)
+        self.containerNode.targetNodeForActivationProgress = self.contextSourceNode.contentNode
+        
+        self.addSubnode(self.activateArea)
+        
+        self.containerNode.activated = { [weak self] gesture, _ in
+            guard let strongSelf = self, let item = strongSelf.item, let contextAction = item.contextAction else {
+                gesture.cancel()
+                return
+            }
+            contextAction(strongSelf.contextSourceNode, gesture)
+        }
+        
+        self.contextSourceNode.willUpdateIsExtractedToContextPreview = { [weak self] isExtracted, transition in
+            guard let strongSelf = self, let item = strongSelf.item else {
+                return
+            }
+            
+            if isExtracted {
+                strongSelf.extractedBackgroundImageNode.image = generateStretchableFilledCircleImage(diameter: 28.0, color: item.presentationData.theme.list.itemBlocksBackgroundColor)
+            }
+            
+            if let extractedRect = strongSelf.extractedRect, let nonExtractedRect = strongSelf.nonExtractedRect {
+                let rect = isExtracted ? extractedRect : nonExtractedRect
+                transition.updateFrame(node: strongSelf.extractedBackgroundImageNode, frame: rect)
+            }
+                        
+            transition.updateAlpha(node: strongSelf.countersContainerNode, alpha: isExtracted ? 0.0 : 1.0)
+
+            transition.updateSublayerTransformOffset(layer: strongSelf.countersContainerNode.layer, offset: CGPoint(x: isExtracted ? -16.0 : 0.0, y: 0.0))
+            transition.updateSublayerTransformOffset(layer: strongSelf.offsetContainerNode.layer, offset: CGPoint(x: isExtracted ? 16.0 : 0.0, y: 0.0))
+                       
+            transition.updateAlpha(node: strongSelf.extractedBackgroundImageNode, alpha: isExtracted ? 1.0 : 0.0, completion: { _ in
+                if !isExtracted {
+                    self?.extractedBackgroundImageNode.image = nil
+                }
+            })
+        }
+    }
+    
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        let result = super.hitTest(point, with: event)
+        return result
+    }
+    
+    override func selected() {
+        guard let item = self.item else {
+            return
+        }
+        if item.isPeer {
+            if case .story = item.item {
+                self.storyPressed()
+            } else {
+                item.action?()
+            }
+        } else {
+            item.action?()
+        }
+    }
+    
+    @objc private func storyPressed() {
+        guard let item = self.item else {
+            return
+        }
+        if let avatarNode = self.avatarNode {
+            item.openStory(avatarNode.view)
+        } else {
+            item.openStory(self.contentImageNode.view)
+        }
+    }
+    
+    public func asyncLayout() -> (_ item: StatsMessageItem, _ params: ListViewItemLayoutParams, _ insets: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeLabelLayout = TextNode.asyncLayout(self.labelNode)
+        let makeViewsLayout = TextNode.asyncLayout(self.viewsNode)
+        let makeReactionsLayout = TextNode.asyncLayout(self.reactionsNode)
+        let makeForwardsLayout = TextNode.asyncLayout(self.forwardsNode)
+        
+        let currentItem = self.item
+        let currentContentImageMedia = self.contentImageMedia
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+                      
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+                        
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            
+            let leftInset = 16.0 + params.leftInset
+            let rightInset = 16.0 + params.rightInset
+            var totalLeftInset = leftInset
+        
+            let titleFont = Font.semibold(item.presentationData.fontSize.itemListBaseFontSize)
+            let labelFont = Font.regular(floor(item.presentationData.fontSize.itemListBaseFontSize * 13.0 / 17.0))
+            
+            let presentationData = item.context.sharedContext.currentPresentationData.with { $0 }
+            
+            var text: String
+            var contentImageMedia: Media?
+            let timestamp: Int32
+            
+            switch item.item {
+            case let .message(message):
+                let contentKind: MessageContentKind
+                contentKind = messageContentKind(contentSettings: item.context.currentContentSettings.with { $0 }, message: EngineMessage(message), strings: item.presentationData.strings, nameDisplayOrder: .firstLast,  dateTimeFormat: presentationData.dateTimeFormat, accountPeerId: item.context.account.peerId)
+                text = !message.text.isEmpty ? message.text : stringForMediaKind(contentKind, strings: item.presentationData.strings).0.string
+                
+                for media in message.media {
+                    if let image = media as? TelegramMediaImage {
+                        contentImageMedia = image
+                        break
+                    } else if let file = media as? TelegramMediaFile {
+                        if file.isVideo && !file.isInstantVideo {
+                            contentImageMedia = file
+                            break
+                        }
+                    } else if let webpage = media as? TelegramMediaWebpage, case let .Loaded(content) = webpage.content {
+                        if let image = content.image {
+                            contentImageMedia = image
+                            break
+                        } else if let file = content.file {
+                            if file.isVideo && !file.isInstantVideo {
+                                contentImageMedia = file
+                                break
+                            }
+                        }
+                    }
+                }
+                timestamp = message.timestamp
+            case let .story(_, story):
+                text = item.presentationData.strings.Message_Story
+                timestamp = story.timestamp
+                if let image = story.media._asMedia() as? TelegramMediaImage {
+                    contentImageMedia = image
+                    break
+                } else if let file = story.media._asMedia() as? TelegramMediaFile {
+                    contentImageMedia = file
+                    break
+                }
+            }
+            
+            if item.isPeer {
+                text = EnginePeer(item.peer).displayTitle(strings: item.presentationData.strings, displayOrder: item.presentationData.nameDisplayOrder)
+            } else {
+                text = foldLineBreaks(text)
+            }
+            
+            if contentImageMedia != nil || item.isPeer {
+                totalLeftInset += 46.0
+            }
+            
+            var updateImageSignal: Signal<(TransformImageArguments) -> DrawingContext?, NoError>?
+            if let contentImageMedia = contentImageMedia {
+                if let currentContentImageMedia = currentContentImageMedia, contentImageMedia.isSemanticallyEqual(to: currentContentImageMedia) {
+                } else {
+                    switch item.item {
+                    case let .message(message):
+                        if let image = contentImageMedia as? TelegramMediaImage {
+                            updateImageSignal = mediaGridMessagePhoto(account: item.context.account, userLocation: .peer(message.id.peerId), photoReference: .message(message: MessageReference(message), media: image))
+                        } else if let file = contentImageMedia as? TelegramMediaFile {
+                            updateImageSignal = mediaGridMessageVideo(postbox: item.context.account.postbox, userLocation: .peer(message.id.peerId), videoReference: .message(message: MessageReference(message), media: file), autoFetchFullSizeThumbnail: true)
+                        }
+                    case let .story(_, story):
+                        if let peerReference = PeerReference(item.peer) {
+                            if let image = contentImageMedia as? TelegramMediaImage {
+                                updateImageSignal = mediaGridMessagePhoto(account: item.context.account, userLocation: .peer(item.peer.id), photoReference: .story(peer: peerReference, id: story.id, media: image))
+                            } else if let file = contentImageMedia as? TelegramMediaFile {
+                                updateImageSignal = mediaGridMessageVideo(postbox: item.context.account.postbox, userLocation: .peer(item.peer.id), videoReference: .story(peer: peerReference, id: story.id, media: file), autoFetchFullSizeThumbnail: true)
+                            }
+                        }
+                    }
+                }
+            }
+            
+            let viewsString: String
+            if item.views == 0 {
+                viewsString = item.presentationData.strings.Stats_MessageViews_NoViews
+            } else {
+                viewsString = item.presentationData.strings.Stats_MessageViews(item.views)
+            }
+            let (viewsLayout, viewsApply) = makeViewsLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: viewsString, font: labelFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: 128.0, height: CGFloat.greatestFiniteMagnitude), alignment: .right, cutout: nil, insets: UIEdgeInsets()))
+            
+            let reactions = item.reactions > 0 ? compactNumericCountString(Int(item.reactions), decimalSeparator: item.presentationData.dateTimeFormat.decimalSeparator) : ""
+            let (reactionsLayout, reactionsApply) = makeReactionsLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: reactions, font: labelFont, textColor: item.presentationData.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: 128.0, height: CGFloat.greatestFiniteMagnitude), alignment: .right, cutout: nil, insets: UIEdgeInsets()))
+            
+            let forwards = item.forwards > 0 ? compactNumericCountString(Int(item.forwards), decimalSeparator: item.presentationData.dateTimeFormat.decimalSeparator) : ""
+            let (forwardsLayout, forwardsApply) = makeForwardsLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: forwards, font: labelFont, textColor: item.presentationData.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: 128.0, height: CGFloat.greatestFiniteMagnitude), alignment: .right, cutout: nil, insets: UIEdgeInsets()))
+            
+            let additionalRightInset = max(viewsLayout.size.width, reactionsLayout.size.width + forwardsLayout.size.width + 36.0) + 8.0
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: text, font: titleFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - totalLeftInset - rightInset - additionalRightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+                                    
+            let label = stringForMediumDate(timestamp: timestamp, strings: item.presentationData.strings, dateTimeFormat: presentationData.dateTimeFormat)
+            let (labelLayout, labelApply) = makeLabelLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: label, font: labelFont, textColor: item.presentationData.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - totalLeftInset - rightInset - additionalRightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let verticalInset: CGFloat = 10.0
+            let titleSpacing: CGFloat = 3.0
+            
+            let height: CGFloat = verticalInset * 2.0 + titleLayout.size.height + titleSpacing + labelLayout.size.height
+         
+            switch item.style {
+            case .plain:
+                itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemPlainSeparatorColor
+                contentSize = CGSize(width: params.width, height: height)
+                insets = itemListNeighborsPlainInsets(neighbors)
+            case .blocks:
+                itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                contentSize = CGSize(width: params.width, height: height)
+                insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (ListViewItemNodeLayout(contentSize: contentSize, insets: insets), { [weak self] in
+                if let strongSelf = self {
+                    let themeUpdated = strongSelf.item?.presentationData.theme !== item.presentationData.theme
+                    strongSelf.item = item
+                    
+                    if themeUpdated {
+                        strongSelf.forwardsIconNode.image = PresentationResourcesItemList.statsForwardsIcon(item.presentationData.theme)
+                        strongSelf.reactionsIconNode.image = PresentationResourcesItemList.statsReactionsIcon(item.presentationData.theme)
+                    }
+                    
+                    let nonExtractedRect = CGRect(origin: CGPoint(), size: CGSize(width: layout.contentSize.width - 16.0, height: layout.contentSize.height))
+                    let extractedRect = CGRect(origin: CGPoint(), size: layout.contentSize).insetBy(dx: 16.0 + params.leftInset, dy: 0.0)
+                    strongSelf.extractedRect = extractedRect
+                    strongSelf.nonExtractedRect = nonExtractedRect
+                    
+                    if strongSelf.contextSourceNode.isExtractedToContextPreview {
+                        strongSelf.extractedBackgroundImageNode.frame = extractedRect
+                    } else {
+                        strongSelf.extractedBackgroundImageNode.frame = nonExtractedRect
+                    }
+                    strongSelf.contextSourceNode.contentRect = extractedRect
+                    
+                    strongSelf.containerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.offsetContainerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.countersContainerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.contentNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.containerNode.isGestureEnabled = item.contextAction != nil
+                    
+                    strongSelf.activateArea.frame = CGRect(origin: CGPoint(x: params.leftInset, y: 0.0), size: CGSize(width: params.width - params.leftInset - params.rightInset, height: layout.contentSize.height))
+                    strongSelf.activateArea.accessibilityLabel = text
+                    strongSelf.activateArea.accessibilityValue = label
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.presentationData.theme.list.itemHighlightedBackgroundColor
+                    }
+                    
+                    var contentImageSize = CGSize(width: 40.0, height: 40.0)
+                    
+                    var contentImageInset = leftInset - 6.0
+                    var dimensions: CGSize?
+                    if item.isPeer {
+                        let avatarNode: AvatarNode
+                        if let current = strongSelf.avatarNode {
+                            avatarNode = current
+                        } else {
+                            avatarNode = AvatarNode(font: avatarPlaceholderFont(size: floor(40.0 * 16.0 / 37.0)))
+                            strongSelf.offsetContainerNode.addSubnode(avatarNode)
+                            strongSelf.avatarNode = avatarNode
+                        }
+                        avatarNode.setPeer(context: item.context, theme: item.presentationData.theme, peer: EnginePeer(item.peer))
+                        
+                        if case .story = item.item {
+                            contentImageInset += 3.0
+                            contentImageSize = CGSize(width: 34.0, height: 34.0)
+                        }
+                    } else {
+                        strongSelf.avatarNode?.removeFromSupernode()
+                        strongSelf.avatarNode = nil
+                        
+                        if let contentImageMedia = contentImageMedia as? TelegramMediaImage {
+                            dimensions = largestRepresentationForPhoto(contentImageMedia)?.dimensions.cgSize
+                        } else if let contentImageMedia = contentImageMedia as? TelegramMediaFile {
+                            dimensions = contentImageMedia.dimensions?.cgSize
+                        }
+                    }
+                
+                    if let dimensions = dimensions {
+                        let makeImageLayout = strongSelf.contentImageNode.asyncLayout()
+                        
+                        let cornerRadius: CGFloat
+                        if case .story = item.item {
+                            contentImageInset += 3.0
+                            contentImageSize = CGSize(width: 34.0, height: 34.0)
+                            cornerRadius = contentImageSize.width / 2.0
+                        } else {
+                            cornerRadius = 6.0
+                        }
+                        
+                        let applyImageLayout = makeImageLayout(TransformImageArguments(corners: ImageCorners(radius: cornerRadius), imageSize: dimensions.aspectFilled(contentImageSize), boundingSize: contentImageSize, intrinsicInsets: UIEdgeInsets()))
+                        applyImageLayout()
+                        
+                        if let updateImageSignal = updateImageSignal {
+                            strongSelf.contentImageNode.setSignal(updateImageSignal)
+                            if currentContentImageMedia == nil {
+                                strongSelf.contentImageNode.isHidden = false
+                            }
+                        }
+                    } else {
+                        if currentContentImageMedia != nil {
+                            strongSelf.contentImageNode.removeFromSupernode()
+                            strongSelf.contentImageNode.setSignal(.single({ _ in nil }))
+                            strongSelf.contentImageNode.isHidden = true
+                        }
+                    }
+                    
+                    let _ = titleApply()
+                    let _ = labelApply()
+                    let _ = viewsApply()
+                    let _ = forwardsApply()
+                    let _ = reactionsApply()
+                    
+                    switch item.style {
+                    case .plain:
+                        if strongSelf.backgroundNode.supernode != nil {
+                            strongSelf.backgroundNode.removeFromSupernode()
+                        }
+                        if strongSelf.topStripeNode.supernode != nil {
+                            strongSelf.topStripeNode.removeFromSupernode()
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                        }
+                        if strongSelf.maskNode.supernode != nil {
+                            strongSelf.maskNode.removeFromSupernode()
+                        }
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: leftInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - leftInset, height: separatorHeight))
+                    case .blocks:
+                        if strongSelf.backgroundNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                        }
+                        if strongSelf.topStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                        }
+                        if strongSelf.maskNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                        }
+                        
+                        let hasCorners = itemListHasRoundedBlockLayout(params)
+                        var hasTopCorners = false
+                        var hasBottomCorners = false
+                        switch neighbors.top {
+                            case .sameSection(false):
+                                strongSelf.topStripeNode.isHidden = true
+                            default:
+                                hasTopCorners = true
+                                strongSelf.topStripeNode.isHidden = hasCorners
+                        }
+                        let bottomStripeInset: CGFloat
+                        switch neighbors.bottom {
+                            case .sameSection(false):
+                                bottomStripeInset = totalLeftInset
+                                strongSelf.bottomStripeNode.isHidden = false
+                            default:
+                                bottomStripeInset = 0.0
+                                hasBottomCorners = true
+                                strongSelf.bottomStripeNode.isHidden = hasCorners
+                        }
+                        
+                        strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners) : nil
+                        
+                        strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                        strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                        strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset, height: separatorHeight))
+                    }
+                    
+                    let contentImageFrame = CGRect(origin: CGPoint(x: contentImageInset, y: floorToScreenPixels((height - contentImageSize.height) / 2.0)), size: contentImageSize)
+                    strongSelf.contentImageNode.frame = contentImageFrame
+                    
+                    if let avatarNode = strongSelf.avatarNode {
+                        avatarNode.frame = contentImageFrame
+                    }
+                    
+                    let titleFrame = CGRect(origin: CGPoint(x: totalLeftInset, y: 9.0), size: titleLayout.size)
+                    strongSelf.titleNode.frame = titleFrame
+                                        
+                    let labelFrame = CGRect(origin: CGPoint(x: totalLeftInset, y: titleFrame.maxY + titleSpacing), size: labelLayout.size)
+                    strongSelf.labelNode.frame = labelFrame
+                    
+                    let viewsOriginY: CGFloat = forwardsLayout.size.width > 0.0 || reactionsLayout.size.width > 0.0 ? 13.0 : floorToScreenPixels((contentSize.height - viewsLayout.size.height) / 2.0)
+                    let viewsFrame = CGRect(origin: CGPoint(x: params.width - rightInset - viewsLayout.size.width, y: viewsOriginY), size: viewsLayout.size)
+                    strongSelf.viewsNode.frame = viewsFrame
+                    
+                    let iconSpacing: CGFloat = 3.0 - UIScreenPixel
+                    
+                    var rightContentInset: CGFloat = rightInset
+                    if forwardsLayout.size.width > 0.0 {
+                        strongSelf.forwardsIconNode.isHidden = false
+                        strongSelf.forwardsNode.isHidden = false
+                        
+                        let forwardsFrame = CGRect(origin: CGPoint(x: params.width - rightContentInset - forwardsLayout.size.width, y: titleFrame.maxY + titleSpacing), size: forwardsLayout.size)
+                        strongSelf.forwardsNode.frame = forwardsFrame
+                        
+                        if let icon = strongSelf.forwardsIconNode.image {
+                            let forwardsIconFrame = CGRect(origin: CGPoint(x: params.width - rightContentInset - forwardsLayout.size.width - icon.size.width - iconSpacing, y: titleFrame.maxY + titleSpacing - 2.0 + UIScreenPixel), size: icon.size)
+                            strongSelf.forwardsIconNode.frame = forwardsIconFrame
+                            
+                            rightContentInset += forwardsIconFrame.width + forwardsFrame.width + iconSpacing
+                        }
+                        rightContentInset += 10.0
+                    } else {
+                        strongSelf.forwardsIconNode.isHidden = true
+                        strongSelf.forwardsNode.isHidden = true
+                    }
+                    
+                    if reactionsLayout.size.width > 0.0 {
+                        strongSelf.reactionsIconNode.isHidden = false
+                        strongSelf.reactionsNode.isHidden = false
+                        
+                        let reactionsFrame = CGRect(origin: CGPoint(x: params.width - rightContentInset - reactionsLayout.size.width, y: titleFrame.maxY + titleSpacing), size: reactionsLayout.size)
+                        strongSelf.reactionsNode.frame = reactionsFrame
+                        
+                        if let icon = strongSelf.reactionsIconNode.image {
+                            let reactionsIconFrame = CGRect(origin: CGPoint(x: params.width - rightContentInset - reactionsLayout.size.width - icon.size.width - iconSpacing, y: titleFrame.maxY + titleSpacing - 2.0 + UIScreenPixel), size: icon.size)
+                            strongSelf.reactionsIconNode.frame = reactionsIconFrame
+                            
+                            rightContentInset += reactionsIconFrame.width + reactionsFrame.width + iconSpacing
+                        }
+                    } else {
+                        strongSelf.reactionsIconNode.isHidden = true
+                        strongSelf.reactionsNode.isHidden = true
+                    }
+                    
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: height + UIScreenPixel))
+                    
+                    if case .story = item.item {
+                        let lineWidth: CGFloat = 1.5
+                        let imageSize = CGSize(width: contentImageFrame.width + 6.0, height: contentImageFrame.height + 6.0)
+                        let indicatorSize = CGSize(width: imageSize.width - lineWidth * 4.0, height: imageSize.height - lineWidth * 4.0)
+
+                        let storyIndicator: ComponentView<Empty>
+                        let indicatorTransition: ComponentTransition = .immediate
+                        if let current = strongSelf.storyIndicator {
+                            storyIndicator = current
+                        } else {
+                            storyIndicator = ComponentView()
+                            strongSelf.storyIndicator = storyIndicator
+                        }
+                        let _ = storyIndicator.update(
+                            transition: indicatorTransition,
+                            component: AnyComponent(AvatarStoryIndicatorComponent(
+                                hasUnseen: true,
+                                hasUnseenCloseFriendsItems: false,
+                                hasLiveItems: false,
+                                colors: AvatarStoryIndicatorComponent.Colors(
+                                    unseenColors: item.presentationData.theme.chatList.storyUnseenColors.array,
+                                    unseenCloseFriendsColors: item.presentationData.theme.chatList.storyUnseenPrivateColors.array,
+                                    seenColors: item.presentationData.theme.chatList.storySeenColors.array
+                                ),
+                                activeLineWidth: lineWidth,
+                                inactiveLineWidth: lineWidth,
+                                counters: AvatarStoryIndicatorComponent.Counters(
+                                    totalCount: 1,
+                                    unseenCount: 1
+                                ),
+                                progress: nil
+                            )),
+                            environment: {},
+                            containerSize: indicatorSize
+                        )
+                        let storyIndicatorFrame = CGRect(origin: CGPoint(x: contentImageFrame.midX - indicatorSize.width / 2.0, y: contentImageFrame.midY - indicatorSize.height / 2.0), size: indicatorSize)
+                        if let storyIndicatorView = storyIndicator.view {
+                            if storyIndicatorView.superview == nil {
+                                strongSelf.offsetContainerNode.view.addSubview(storyIndicatorView)
+                            }
+                            indicatorTransition.setFrame(view: storyIndicatorView, frame: storyIndicatorFrame)
+                        }
+                        
+                        let storyButton: HighlightTrackingButton
+                        if let current = strongSelf.storyButton {
+                            storyButton = current
+                        } else {
+                            storyButton = HighlightTrackingButton()
+                            storyButton.addTarget(strongSelf, action: #selector(strongSelf.storyPressed), for: .touchUpInside)
+                            strongSelf.view.addSubview(storyButton)
+                            strongSelf.storyButton = storyButton
+                        }
+                        storyButton.frame = storyIndicatorFrame
+                    } else if let storyIndicator = strongSelf.storyIndicator {
+                        if let storyIndicatorView = storyIndicator.view {
+                            storyIndicatorView.removeFromSuperview()
+                        }
+                        strongSelf.storyIndicator = nil
+                        
+                        if let storyButton = strongSelf.storyButton {
+                            storyButton.removeFromSuperview()
+                            strongSelf.storyButton = nil
+                        }
+                    }
+                }
+            })
+        }
+    }
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        var highlighted = highlighted
+        if let avatarButton = self.storyButton, avatarButton.bounds.contains(self.view.convert(point, to: storyButton)) {
+            highlighted = false
+        }
+        
+        if highlighted {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                        })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateAdded(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}

submodules/StatisticsUI/Sources/StoryIconNode.swift

@@ -0,0 +1,108 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import ComponentFlow
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import PhotoResources
+import AvatarStoryIndicatorComponent
+import AccountContext
+import TelegramPresentationData
+
+final class StoryIconNode: ASDisplayNode {
+    private let imageNode = TransformImageNode()
+    private let storyIndicator = ComponentView<Empty>()
+    
+    init(context: AccountContext, theme: PresentationTheme, peer: Peer, storyItem: EngineStoryItem) {
+        self.imageNode.displaysAsynchronously = false
+        
+        super.init()
+        
+        self.addSubnode(self.imageNode)
+       
+        let imageSize = CGSize(width: 30.0, height: 30.0)
+        let size = CGSize(width: 36.0, height: 36.0)
+        let bounds = CGRect(origin: .zero, size: size)
+        
+        self.imageNode.frame = bounds.insetBy(dx: 3.0, dy: 3.0)
+        self.frame = bounds
+        
+        let media: Media?
+        switch storyItem.media {
+        case let .image(image):
+            media = image
+        case let .file(file):
+            media = file
+        default:
+            media = nil
+        }
+        
+        var updateImageSignal: Signal<(TransformImageArguments) -> DrawingContext?, NoError>?
+        var dimensions: CGSize?
+        if let peerReference = PeerReference(peer), let media {
+            if let image = media as? TelegramMediaImage {
+                updateImageSignal = mediaGridMessagePhoto(account: context.account, userLocation: .peer(peer.id), photoReference: .story(peer: peerReference, id: storyItem.id, media: image))
+                dimensions = largestRepresentationForPhoto(image)?.dimensions.cgSize
+            } else if let file = media as? TelegramMediaFile {
+                updateImageSignal = mediaGridMessageVideo(postbox: context.account.postbox, userLocation: .peer(peer.id), videoReference: .story(peer: peerReference, id: storyItem.id, media: file), autoFetchFullSizeThumbnail: true)
+                dimensions = file.dimensions?.cgSize
+            }
+        }
+
+        if let updateImageSignal {
+            self.imageNode.setSignal(updateImageSignal)
+        }
+        
+        if let dimensions {
+            let cornerRadius = imageSize.width / 2.0
+            let makeImageLayout = self.imageNode.asyncLayout()
+            let applyImageLayout = makeImageLayout(TransformImageArguments(corners: ImageCorners(radius: cornerRadius), imageSize: dimensions.aspectFilled(imageSize), boundingSize: imageSize, intrinsicInsets: UIEdgeInsets()))
+            applyImageLayout()
+        }
+        
+        let lineWidth: CGFloat = 1.5
+        let indicatorSize = CGSize(width: size.width - lineWidth * 4.0, height: size.height - lineWidth * 4.0)
+
+        let _ = self.storyIndicator.update(
+            transition: .immediate,
+            component: AnyComponent(AvatarStoryIndicatorComponent(
+                hasUnseen: true,
+                hasUnseenCloseFriendsItems: false,
+                hasLiveItems: false,
+                colors: AvatarStoryIndicatorComponent.Colors(
+                    unseenColors: theme.chatList.storyUnseenColors.array,
+                    unseenCloseFriendsColors: theme.chatList.storyUnseenPrivateColors.array,
+                    seenColors: theme.chatList.storySeenColors.array
+                ),
+                activeLineWidth: lineWidth,
+                inactiveLineWidth: lineWidth,
+                counters: AvatarStoryIndicatorComponent.Counters(
+                    totalCount: 1,
+                    unseenCount: 1
+                ),
+                progress: nil
+            )),
+            environment: {},
+            containerSize: indicatorSize
+        )
+        if let storyIndicatorView = self.storyIndicator.view {
+            storyIndicatorView.frame = CGRect(origin: CGPoint(x: bounds.midX - indicatorSize.width / 2.0, y: bounds.midY - indicatorSize.height / 2.0), size: indicatorSize)
+        }
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        if let storyIndicatorView = self.storyIndicator.view {
+            if storyIndicatorView.superview == nil {
+                self.view.addSubview(storyIndicatorView)
+            }
+        }
+    }
+
+    override public func calculateSizeThatFits(_ constrainedSize: CGSize) -> CGSize {
+        return CGSize(width: 36.0, height: 36.0)
+    }
+}

submodules/StatisticsUI/Sources/TransactionInfoScreen.swift

@@ -0,0 +1,483 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import SwiftSignalKit
+import TelegramCore
+import Markdown
+import TextFormat
+import TelegramPresentationData
+import ViewControllerComponent
+import SheetComponent
+import BundleIconComponent
+import BalancedTextComponent
+import MultilineTextComponent
+import SolidRoundedButtonComponent
+import LottieComponent
+import AccountContext
+import TelegramStringFormatting
+import PremiumPeerShortcutComponent
+
+private final class SheetContent: CombinedComponent {
+    typealias EnvironmentType = ViewControllerComponentContainer.Environment
+    
+    let context: AccountContext
+    let peer: EnginePeer
+    let transaction: StarsContext.State.Transaction
+    let openExplorer: (String) -> Void
+    let dismiss: () -> Void
+    
+    init(
+        context: AccountContext,
+        peer: EnginePeer,
+        transaction: StarsContext.State.Transaction,
+        openExplorer: @escaping (String) -> Void,
+        dismiss: @escaping () -> Void
+    ) {
+        self.context = context
+        self.peer = peer
+        self.transaction = transaction
+        self.openExplorer = openExplorer
+        self.dismiss = dismiss
+    }
+    
+    static func ==(lhs: SheetContent, rhs: SheetContent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.peer != rhs.peer {
+            return false
+        }
+        if lhs.transaction != rhs.transaction {
+            return false
+        }
+        return true
+    }
+    
+    final class State: ComponentState {
+        var cachedCloseImage: (UIImage, PresentationTheme)?
+        
+        let playOnce =  ActionSlot<Void>()
+        private var didPlayAnimation = false
+                
+        func playAnimationIfNeeded() {
+            guard !self.didPlayAnimation else {
+                return
+            }
+            self.didPlayAnimation = true
+            self.playOnce.invoke(Void())
+        }
+    }
+    
+    func makeState() -> State {
+        return State()
+    }
+    
+    static var body: Body {
+        let closeButton = Child(Button.self)
+                
+        let amount = Child(MultilineTextComponent.self)
+        let title = Child(MultilineTextComponent.self)
+        let date = Child(MultilineTextComponent.self)
+        let peerShortcut = Child(PremiumPeerShortcutComponent.self)
+        
+        let actionButton = Child(SolidRoundedButtonComponent.self)
+
+        return { context in
+            let environment = context.environment[EnvironmentType.self]
+            let component = context.component
+            let state = context.state
+            
+            let theme = environment.theme
+            let strings = environment.strings
+            let dateTimeFormat = component.context.sharedContext.currentPresentationData.with { $0 }.dateTimeFormat
+            
+            let sideInset: CGFloat = 16.0 + environment.safeInsets.left
+            let textSideInset: CGFloat = 32.0 + environment.safeInsets.left
+            
+            let titleFont = Font.semibold(17.0)
+            let textFont = Font.regular(17.0)
+            
+            var titleColor = theme.actionSheet.primaryTextColor
+            let secondaryTextColor = theme.actionSheet.secondaryTextColor
+            
+            var contentSize = CGSize(width: context.availableSize.width, height: 45.0)
+            
+            let closeImage: UIImage
+            if let (image, theme) = state.cachedCloseImage, theme === environment.theme {
+                closeImage = image
+            } else {
+                closeImage = generateCloseButtonImage(backgroundColor: UIColor(rgb: 0x808084, alpha: 0.1), foregroundColor: theme.actionSheet.inputClearButtonColor)!
+                state.cachedCloseImage = (closeImage, theme)
+            }
+            
+            let closeButton = closeButton.update(
+                component: Button(
+                    content: AnyComponent(Image(image: closeImage)),
+                    action: { [weak component] in
+                        component?.dismiss()
+                    }
+                ),
+                availableSize: CGSize(width: 30.0, height: 30.0),
+                transition: .immediate
+            )
+            context.add(closeButton
+                .position(CGPoint(x: context.availableSize.width - environment.safeInsets.left - closeButton.size.width, y: 28.0))
+            )
+            
+            let amountString: NSMutableAttributedString
+            let dateString: String
+            let titleString: String
+            let buttonTitle: String
+            let explorerUrl: String?
+            
+            let integralFont = Font.with(size: 48.0, design: .round, weight: .semibold)
+            let fractionalFont = Font.with(size: 24.0, design: .round, weight: .semibold)
+            let labelColor: UIColor
+            
+            var showPeer = false
+            if let fromDate = component.transaction.adsProceedsFromDate, let toDate = component.transaction.adsProceedsToDate {
+                labelColor = theme.list.itemDisclosureActions.constructive.fillColor
+                amountString = tonAmountAttributedString(formatTonAmountText(component.transaction.count.amount.value, dateTimeFormat: dateTimeFormat, showPlus: true), integralFont: integralFont, fractionalFont: fractionalFont, color: labelColor, decimalSeparator: dateTimeFormat.decimalSeparator).mutableCopy() as! NSMutableAttributedString
+                dateString = "\(stringForMediumCompactDate(timestamp: fromDate, strings: strings, dateTimeFormat: dateTimeFormat)) – \(stringForMediumCompactDate(timestamp: toDate, strings: strings, dateTimeFormat: dateTimeFormat))"
+                titleString = strings.Monetization_TransactionInfo_Proceeds
+                buttonTitle = strings.Common_OK
+                explorerUrl = nil
+                showPeer = true
+            } else if case .fragment = component.transaction.peer {
+                if component.transaction.flags.contains(.isRefund) {
+                    labelColor = theme.list.itemDisclosureActions.constructive.fillColor
+                    titleString = strings.Monetization_TransactionInfo_Refund
+                    amountString = tonAmountAttributedString(formatTonAmountText(component.transaction.count.amount.value, dateTimeFormat: dateTimeFormat, showPlus: true), integralFont: integralFont, fractionalFont: fractionalFont, color: labelColor, decimalSeparator: dateTimeFormat.decimalSeparator).mutableCopy() as! NSMutableAttributedString
+                    dateString = stringForFullDate(timestamp: component.transaction.date, strings: strings, dateTimeFormat: dateTimeFormat)
+                    buttonTitle = strings.Common_OK
+                } else {
+                    labelColor = theme.list.itemDestructiveColor
+                    amountString = tonAmountAttributedString(formatTonAmountText(component.transaction.count.amount.value, dateTimeFormat: dateTimeFormat), integralFont: integralFont, fractionalFont: fractionalFont, color: labelColor, decimalSeparator: dateTimeFormat.decimalSeparator).mutableCopy() as! NSMutableAttributedString
+                    dateString = stringForFullDate(timestamp: component.transaction.date, strings: strings, dateTimeFormat: dateTimeFormat)
+                    
+                    if component.transaction.flags.contains(.isPending) {
+                        titleString = strings.Monetization_TransactionInfo_Pending
+                        buttonTitle = strings.Common_OK
+                    } else if component.transaction.flags.contains(.isFailed) {
+                        titleString = strings.Monetization_TransactionInfo_Failed
+                        buttonTitle = strings.Common_OK
+                        titleColor = theme.list.itemDestructiveColor
+                    } else {
+                        titleString = strings.Monetization_TransactionInfo_Withdrawal("Fragment").string
+                        buttonTitle = strings.Monetization_TransactionInfo_ViewInExplorer
+                    }
+                }
+                explorerUrl = component.transaction.transactionUrl
+            } else if component.transaction.flags.contains(.isRefund) {
+                labelColor = theme.list.itemDisclosureActions.constructive.fillColor
+                titleString = strings.Monetization_TransactionInfo_Refund
+                amountString = tonAmountAttributedString(formatTonAmountText(component.transaction.count.amount.value, dateTimeFormat: dateTimeFormat, showPlus: true), integralFont: integralFont, fractionalFont: fractionalFont, color: labelColor, decimalSeparator: dateTimeFormat.decimalSeparator).mutableCopy() as! NSMutableAttributedString
+                dateString = stringForFullDate(timestamp: component.transaction.date, strings: strings, dateTimeFormat: dateTimeFormat)
+                buttonTitle = strings.Common_OK
+                explorerUrl = nil
+            } else {
+                labelColor = theme.list.itemDisclosureActions.constructive.fillColor
+                amountString = tonAmountAttributedString(formatTonAmountText(component.transaction.count.amount.value, dateTimeFormat: dateTimeFormat, showPlus: true), integralFont: integralFont, fractionalFont: fractionalFont, color: labelColor, decimalSeparator: dateTimeFormat.decimalSeparator).mutableCopy() as! NSMutableAttributedString
+                dateString = ""
+                titleString = ""
+                buttonTitle = ""
+                explorerUrl = nil
+            }
+            
+            amountString.insert(NSAttributedString(string: " $ ", font: integralFont, textColor: labelColor), at: 1)
+            if let range = amountString.string.range(of: "$"), let icon = generateTintedImage(image: UIImage(bundleImageName: "Ads/TonBig"), color: labelColor) {
+                amountString.addAttribute(.attachment, value: icon, range: NSRange(range, in: amountString.string))
+                amountString.addAttribute(.baselineOffset, value: 1.0, range: NSRange(range, in: amountString.string))
+            }
+            
+            let amount = amount.update(
+                component: MultilineTextComponent(
+                    text: .plain(amountString),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 1,
+                    lineSpacing: 0.1
+                ),
+                availableSize: CGSize(width: context.availableSize.width - textSideInset * 2.0, height: context.availableSize.height),
+                transition: .immediate
+            )
+            context.add(amount
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + amount.size.height / 2.0))
+            )
+            contentSize.height += amount.size.height
+            contentSize.height += -5.0
+            
+            let date = date.update(
+                component: MultilineTextComponent(
+                    text: .plain(NSAttributedString(string: dateString, font: textFont, textColor: secondaryTextColor)),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 0,
+                    lineSpacing: 0.1
+                ),
+                availableSize: CGSize(width: context.availableSize.width - textSideInset * 2.0, height: context.availableSize.height),
+                transition: .immediate
+            )
+            context.add(date
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + date.size.height / 2.0))
+            )
+            contentSize.height += date.size.height
+            contentSize.height += 32.0
+            
+            let title = title.update(
+                component: MultilineTextComponent(
+                    text: .plain(NSAttributedString(string: titleString, font: titleFont, textColor: titleColor)),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 0,
+                    lineSpacing: 0.1
+                ),
+                availableSize: CGSize(width: context.availableSize.width - textSideInset * 2.0, height: context.availableSize.height),
+                transition: .immediate
+            )
+            context.add(title
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + title.size.height / 2.0))
+            )
+            contentSize.height += title.size.height
+            contentSize.height += 3.0
+            
+            if showPeer {
+                contentSize.height += 5.0
+                let peerShortcut = peerShortcut.update(
+                    component: PremiumPeerShortcutComponent(
+                        context: component.context,
+                        theme: theme,
+                        peer: component.peer
+                        
+                    ),
+                    availableSize: CGSize(width: context.availableSize.width - 32.0, height: context.availableSize.height),
+                    transition: .immediate
+                )
+                context.add(peerShortcut
+                    .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + peerShortcut.size.height / 2.0))
+                )
+                contentSize.height += peerShortcut.size.height
+                contentSize.height += 50.0
+            } else {
+                contentSize.height += 45.0
+            }
+           
+            let actionButton = actionButton.update(
+                component: SolidRoundedButtonComponent(
+                    title: buttonTitle,
+                    theme: SolidRoundedButtonComponent.Theme(
+                        backgroundColor: theme.list.itemCheckColors.fillColor,
+                        backgroundColors: [],
+                        foregroundColor: theme.list.itemCheckColors.foregroundColor
+                    ),
+                    font: .bold,
+                    fontSize: 17.0,
+                    height: 50.0,
+                    cornerRadius: 10.0,
+                    gloss: false,
+                    iconName: nil,
+                    animationName: nil,
+                    iconPosition: .left,
+                    action: {
+                        component.dismiss()
+                        if let explorerUrl {
+                            component.openExplorer(explorerUrl)
+                        }
+                    }
+                ),
+                availableSize: CGSize(width: context.availableSize.width - sideInset * 2.0, height: 50.0),
+                transition: context.transition
+            )
+            context.add(actionButton
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: contentSize.height + actionButton.size.height / 2.0))
+            )
+            contentSize.height += actionButton.size.height
+            contentSize.height += 22.0
+                        
+            contentSize.height += environment.safeInsets.bottom
+            
+            state.playAnimationIfNeeded()
+            
+            return contentSize
+        }
+    }
+}
+
+private final class SheetContainerComponent: CombinedComponent {
+    typealias EnvironmentType = ViewControllerComponentContainer.Environment
+    
+    let context: AccountContext
+    let peer: EnginePeer
+    let transaction: StarsContext.State.Transaction
+    let openExplorer: (String) -> Void
+    
+    init(
+        context: AccountContext,
+        peer: EnginePeer,
+        transaction: StarsContext.State.Transaction,
+        openExplorer: @escaping (String) -> Void
+    ) {
+        self.context = context
+        self.peer = peer
+        self.transaction = transaction
+        self.openExplorer = openExplorer
+    }
+    
+    static func ==(lhs: SheetContainerComponent, rhs: SheetContainerComponent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.peer != rhs.peer {
+            return false
+        }
+        if lhs.transaction != rhs.transaction {
+            return false
+        }
+        return true
+    }
+    
+    static var body: Body {
+        let sheet = Child(SheetComponent<EnvironmentType>.self)
+        let animateOut = StoredActionSlot(Action<Void>.self)
+        
+        let sheetExternalState = SheetComponent<EnvironmentType>.ExternalState()
+        
+        return { context in
+            let environment = context.environment[EnvironmentType.self]
+            
+            let controller = environment.controller
+            
+            let sheet = sheet.update(
+                component: SheetComponent<EnvironmentType>(
+                    content: AnyComponent<EnvironmentType>(SheetContent(
+                        context: context.component.context,
+                        peer: context.component.peer,
+                        transaction: context.component.transaction,
+                        openExplorer: context.component.openExplorer,
+                        dismiss: {
+                            animateOut.invoke(Action { _ in
+                                if let controller = controller() {
+                                    controller.dismiss(completion: nil)
+                                }
+                            })
+                        }
+                    )),
+                    backgroundColor: .color(environment.theme.actionSheet.opaqueItemBackgroundColor),
+                    followContentSizeChanges: true,
+                    externalState: sheetExternalState,
+                    animateOut: animateOut
+                ),
+                environment: {
+                    environment
+                    SheetComponentEnvironment(
+                        isDisplaying: environment.value.isVisible,
+                        isCentered: environment.metrics.widthClass == .regular,
+                        hasInputHeight: !environment.inputHeight.isZero,
+                        regularMetricsSize: CGSize(width: 430.0, height: 900.0),
+                        dismiss: { animated in
+                            if animated {
+                                animateOut.invoke(Action { _ in
+                                    if let controller = controller() {
+                                        controller.dismiss(completion: nil)
+                                    }
+                                })
+                            } else {
+                                if let controller = controller() {
+                                    controller.dismiss(completion: nil)
+                                }
+                            }
+                        }
+                    )
+                },
+                availableSize: context.availableSize,
+                transition: context.transition
+            )
+            
+            context.add(sheet
+                .position(CGPoint(x: context.availableSize.width / 2.0, y: context.availableSize.height / 2.0))
+            )
+            
+            if let controller = controller(), !controller.automaticallyControlPresentationContextLayout {
+                let layout = ContainerViewLayout(
+                    size: context.availableSize,
+                    metrics: environment.metrics,
+                    deviceMetrics: environment.deviceMetrics,
+                    intrinsicInsets: UIEdgeInsets(top: 0.0, left: 0.0, bottom: max(environment.safeInsets.bottom, sheetExternalState.contentHeight), right: 0.0),
+                    safeInsets: UIEdgeInsets(top: 0.0, left: environment.safeInsets.left, bottom: 0.0, right: environment.safeInsets.right),
+                    additionalInsets: .zero,
+                    statusBarHeight: environment.statusBarHeight,
+                    inputHeight: nil,
+                    inputHeightIsInteractivellyChanging: false,
+                    inVoiceOver: false
+                )
+                controller.presentationContext.containerLayoutUpdated(layout, transition: context.transition.containedViewLayoutTransition)
+            }
+            
+            return context.availableSize
+        }
+    }
+}
+
+
+final class TransactionInfoScreen: ViewControllerComponentContainer {
+    private let context: AccountContext
+        
+    init(
+        context: AccountContext,
+        peer: EnginePeer,
+        transaction: StarsContext.State.Transaction,
+        openExplorer: @escaping (String) -> Void
+    ) {
+        self.context = context
+                
+        super.init(
+            context: context,
+            component: SheetContainerComponent(
+                context: context,
+                peer: peer,
+                transaction: transaction,
+                openExplorer: openExplorer
+            ),
+            navigationBarAppearance: .none,
+            statusBarStyle: .ignore,
+            theme: .default
+        )
+        
+        self.navigationPresentation = .flatModal
+    }
+    
+    required public init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        
+        self.view.disablesInteractiveModalDismiss = true
+    }
+    
+    func dismissAnimated() {
+        if let view = self.node.hostView.findTaggedView(tag: SheetComponent<ViewControllerComponentContainer.Environment>.View.Tag()) as? SheetComponent<ViewControllerComponentContainer.Environment>.View {
+            view.dismissAnimated()
+        }
+    }
+}
+
+func generateCloseButtonImage(backgroundColor: UIColor, foregroundColor: UIColor) -> UIImage? {
+    return generateImage(CGSize(width: 30.0, height: 30.0), contextGenerator: { size, context in
+        context.clear(CGRect(origin: CGPoint(), size: size))
+        
+        context.setFillColor(backgroundColor.cgColor)
+        context.fillEllipse(in: CGRect(origin: CGPoint(), size: size))
+        
+        context.setLineWidth(2.0)
+        context.setLineCap(.round)
+        context.setStrokeColor(foregroundColor.cgColor)
+        
+        context.move(to: CGPoint(x: 10.0, y: 10.0))
+        context.addLine(to: CGPoint(x: 20.0, y: 20.0))
+        context.strokePath()
+        
+        context.move(to: CGPoint(x: 20.0, y: 10.0))
+        context.addLine(to: CGPoint(x: 10.0, y: 20.0))
+        context.strokePath()
+    })
+}