import Foundation
import UIKit
import Display
import LegacyComponents
import AccountContext
import TelegramPresentationData
import ComponentFlow
import GlassBackgroundComponent
import GlassBarButtonComponent
import PlainButtonComponent
import BundleIconComponent

private let toolbarButtonSide: CGFloat = 44.0
private let toolbarSideButtonSide: CGFloat = 44.0
private let centerButtonSpacing: CGFloat = 10.0

private let toolbarTabOrder: [TGPhotoEditorTab] = [
    .cropTab,
    .stickerTab,
    .paintTab,
    .eraserTab,
    .textTab,
    .toolsTab,
    .rotateTab,
    .qualityTab,
    .timerTab,
    .mirrorTab,
    .aspectRatioTab,
    .tintTab,
    .blurTab,
    .curvesTab
]

private let dontHighlightOnSelectionTabs = Set<UInt>([
    TGPhotoEditorTab.rotateTab.rawValue,
    TGPhotoEditorTab.stickerTab.rawValue,
    TGPhotoEditorTab.textTab.rawValue,
    TGPhotoEditorTab.qualityTab.rawValue,
    TGPhotoEditorTab.timerTab.rawValue,
    TGPhotoEditorTab.mirrorTab.rawValue,
    TGPhotoEditorTab.aspectRatioTab.rawValue
])


private final class MediaPickerPhotoToolbarImageCache {
    private var images: [String: UIImage] = [:]

    func qualityIcon(isPhoto: Bool, highQuality: Bool, preset: Int, color: UIColor) -> UIImage? {
        let key = "quality-\(isPhoto)-\(highQuality)-\(preset)-\(self.colorKey(color))"
        if let image = self.images[key] {
            return image
        }
        let image = generateQualityIcon(isPhoto: isPhoto, highQuality: highQuality, preset: preset, color: color)
        self.images[key] = image
        return image
    }

    func timerIcon(value: Int, color: UIColor) -> UIImage? {
        let key = "timer-\(value)-\(self.colorKey(color))"
        if let image = self.images[key] {
            return image
        }
        let image = generateTimerIcon(value: value, color: color)
        self.images[key] = image
        return image
    }

    private func colorKey(_ color: UIColor) -> String {
        var red: CGFloat = 0.0
        var green: CGFloat = 0.0
        var blue: CGFloat = 0.0
        var alpha: CGFloat = 0.0
        if color.getRed(&red, green: &green, blue: &blue, alpha: &alpha) {
            return "\(Int(red * 255.0))-\(Int(green * 255.0))-\(Int(blue * 255.0))-\(Int(alpha * 255.0))"
        }
        var white: CGFloat = 0.0
        if color.getWhite(&white, alpha: &alpha) {
            return "\(Int(white * 255.0))-\(Int(alpha * 255.0))"
        }
        return color.description
    }
}

private func generateQualityIcon(isPhoto: Bool, highQuality: Bool, preset: Int, color: UIColor) -> UIImage? {
    let label: String
    if isPhoto {
        label = highQuality ? "HD" : "SD"
    } else {
        switch preset {
        case 1:
            label = "240"
        case 2:
            label = "360"
        case 3:
            label = "480"
        case 4:
            label = "720"
        case 5:
            label = "HD"
        default:
            label = "480"
        }
    }

    let size = CGSize(width: isPhoto ? 24.0 : 28.0, height: 24.0)
    let lineWidth = 2.0 - UIScreenPixel
    let rect = CGRect(origin: .zero, size: size).insetBy(dx: lineWidth / 2.0, dy: lineWidth / 2.0)

    UIGraphicsBeginImageContextWithOptions(size, false, 0.0)
    guard let context = UIGraphicsGetCurrentContext() else {
        UIGraphicsEndImageContext()
        return nil
    }

    context.setStrokeColor(color.cgColor)
    context.setLineWidth(lineWidth)
    context.addPath(UIBezierPath(roundedRect: rect, cornerRadius: 7.0).cgPath)
    context.strokePath()

    let font = Font.with(size: 11.0, design: .round, weight: .bold)
    let attributes: [NSAttributedString.Key: Any] = [
        .font: font,
        .foregroundColor: color,
        .kern: -0.7
    ]
    let textSize = label.size(withAttributes: attributes)
    label.draw(
        in: CGRect(
            x: floorToScreenPixels((size.width - textSize.width) / 2.0) + UIScreenPixel,
            y: 5.0,
            width: textSize.width,
            height: textSize.height
        ),
        withAttributes: attributes
    )

    let image = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()
    return image
}

private func generateTimerIcon(value: Int, color: UIColor) -> UIImage? {
    let size = CGSize(width: 24.0, height: 24.0)
    let lineWidth = 2.0 - UIScreenPixel

    UIGraphicsBeginImageContextWithOptions(size, false, 0.0)
    guard let context = UIGraphicsGetCurrentContext() else {
        UIGraphicsEndImageContext()
        return nil
    }

    context.setStrokeColor(color.cgColor)
    context.setLineWidth(lineWidth)
    context.setLineCap(.round)
    context.setLineJoin(.round)

    let bodyRect = CGRect(x: 4.0, y: 5.0, width: 16.0, height: 16.0).insetBy(dx: lineWidth / 2.0, dy: lineWidth / 2.0)
    context.strokeEllipse(in: bodyRect)

    context.move(to: CGPoint(x: 9.0, y: 2.5))
    context.addLine(to: CGPoint(x: 15.0, y: 2.5))
    context.strokePath()

    context.move(to: CGPoint(x: 12.0, y: 5.0))
    context.addLine(to: CGPoint(x: 12.0, y: 8.0))
    context.strokePath()

    if value == 0 {
        context.move(to: CGPoint(x: 12.0, y: 13.0))
        context.addLine(to: CGPoint(x: 12.0, y: 9.0))
        context.move(to: CGPoint(x: 12.0, y: 13.0))
        context.addLine(to: CGPoint(x: 15.0, y: 13.0))
        context.strokePath()
    } else {
        let label = "\(value)"
        let font = Font.with(size: 10.0, design: .round, weight: .semibold)
        let attributes: [NSAttributedString.Key: Any] = [
            .font: font,
            .foregroundColor: color
        ]
        let textSize = label.size(withAttributes: attributes)
        label.draw(
            in: CGRect(
                x: floorToScreenPixels((size.width - textSize.width) / 2.0),
                y: 9.0,
                width: textSize.width,
                height: textSize.height
            ),
            withAttributes: attributes
        )
    }

    let image = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()
    return image
}

private final class MediaPickerPhotoToolbarComponent: Component {
    let context: AccountContext
    let solidBackground: Bool
    let backButtonType: TGPhotoEditorBackButton
    let doneButtonType: TGPhotoEditorDoneButton
    let currentTabs: TGPhotoEditorTab
    let activeTab: TGPhotoEditorTab
    let highlightedTabs: TGPhotoEditorTab
    let disabledTabs: TGPhotoEditorTab
    let qualityIsPhoto: Bool
    let qualityHighQuality: Bool
    let qualityPreset: Int
    let timerValue: Int
    let hasSendStarsButton: Bool
    let sendPaidMessageStars: Int64
    let editButtonsHidden: Bool
    let editButtonsEnabled: Bool
    let centerButtonsHidden: Bool
    let allButtonsHidden: Bool
    let cancelDoneButtonsHidden: Bool
    let doneButtonEnabled: Bool
    let interfaceOrientation: UIInterfaceOrientation
    let bottomInset: CGFloat
    let infoString: String?
    let cancelPressed: (() -> Void)?
    let donePressed: (() -> Void)?
    let doneLongPressed: ((Any?) -> Void)?
    let tabPressed: ((TGPhotoEditorTab) -> Void)?

    init(
        context: AccountContext,
        solidBackground: Bool,
        backButtonType: TGPhotoEditorBackButton,
        doneButtonType: TGPhotoEditorDoneButton,
        currentTabs: TGPhotoEditorTab,
        activeTab: TGPhotoEditorTab,
        highlightedTabs: TGPhotoEditorTab,
        disabledTabs: TGPhotoEditorTab,
        qualityIsPhoto: Bool,
        qualityHighQuality: Bool,
        qualityPreset: Int,
        timerValue: Int,
        hasSendStarsButton: Bool,
        sendPaidMessageStars: Int64,
        editButtonsHidden: Bool,
        editButtonsEnabled: Bool,
        centerButtonsHidden: Bool,
        allButtonsHidden: Bool,
        cancelDoneButtonsHidden: Bool,
        doneButtonEnabled: Bool,
        interfaceOrientation: UIInterfaceOrientation,
        bottomInset: CGFloat,
        infoString: String?,
        cancelPressed: (() -> Void)?,
        donePressed: (() -> Void)?,
        doneLongPressed: ((Any?) -> Void)?,
        tabPressed: ((TGPhotoEditorTab) -> Void)?
    ) {
        self.context = context
        self.solidBackground = solidBackground
        self.backButtonType = backButtonType
        self.doneButtonType = doneButtonType
        self.currentTabs = currentTabs
        self.activeTab = activeTab
        self.highlightedTabs = highlightedTabs
        self.disabledTabs = disabledTabs
        self.qualityIsPhoto = qualityIsPhoto
        self.qualityHighQuality = qualityHighQuality
        self.qualityPreset = qualityPreset
        self.timerValue = timerValue
        self.hasSendStarsButton = hasSendStarsButton
        self.sendPaidMessageStars = sendPaidMessageStars
        self.editButtonsHidden = editButtonsHidden
        self.editButtonsEnabled = editButtonsEnabled
        self.centerButtonsHidden = centerButtonsHidden
        self.allButtonsHidden = allButtonsHidden
        self.cancelDoneButtonsHidden = cancelDoneButtonsHidden
        self.doneButtonEnabled = doneButtonEnabled
        self.interfaceOrientation = interfaceOrientation
        self.bottomInset = bottomInset
        self.infoString = infoString
        self.cancelPressed = cancelPressed
        self.donePressed = donePressed
        self.doneLongPressed = doneLongPressed
        self.tabPressed = tabPressed
    }

    static func ==(lhs: MediaPickerPhotoToolbarComponent, rhs: MediaPickerPhotoToolbarComponent) -> Bool {
        if lhs.context !== rhs.context {
            return false
        }
        if lhs.solidBackground != rhs.solidBackground {
            return false
        }
        if lhs.backButtonType != rhs.backButtonType {
            return false
        }
        if lhs.doneButtonType != rhs.doneButtonType {
            return false
        }
        if lhs.currentTabs != rhs.currentTabs {
            return false
        }
        if lhs.activeTab != rhs.activeTab {
            return false
        }
        if lhs.highlightedTabs != rhs.highlightedTabs {
            return false
        }
        if lhs.disabledTabs != rhs.disabledTabs {
            return false
        }
        if lhs.qualityIsPhoto != rhs.qualityIsPhoto {
            return false
        }
        if lhs.qualityHighQuality != rhs.qualityHighQuality {
            return false
        }
        if lhs.qualityPreset != rhs.qualityPreset {
            return false
        }
        if lhs.timerValue != rhs.timerValue {
            return false
        }
        if lhs.hasSendStarsButton != rhs.hasSendStarsButton {
            return false
        }
        if lhs.sendPaidMessageStars != rhs.sendPaidMessageStars {
            return false
        }
        if lhs.editButtonsHidden != rhs.editButtonsHidden {
            return false
        }
        if lhs.editButtonsEnabled != rhs.editButtonsEnabled {
            return false
        }
        if lhs.centerButtonsHidden != rhs.centerButtonsHidden {
            return false
        }
        if lhs.allButtonsHidden != rhs.allButtonsHidden {
            return false
        }
        if lhs.cancelDoneButtonsHidden != rhs.cancelDoneButtonsHidden {
            return false
        }
        if lhs.doneButtonEnabled != rhs.doneButtonEnabled {
            return false
        }
        if lhs.interfaceOrientation != rhs.interfaceOrientation {
            return false
        }
        if lhs.bottomInset != rhs.bottomInset {
            return false
        }
        if lhs.infoString != rhs.infoString {
            return false
        }
        return true
    }

    final class View: UIView {
        fileprivate let cancelButton = ComponentView<Empty>()
        fileprivate let doneButton = ComponentView<Empty>()
        private let doneButtonContextView = ContextControllerSourceView()

        private let buttonsBackgroundView = GlassBackgroundView()
        private let selectionView = UIView()
        private let infoLabel = UILabel()
        private let imageCache = MediaPickerPhotoToolbarImageCache()
        private var centerButtonViews: [UInt: ComponentView<Empty>] = [:]

        private var component: MediaPickerPhotoToolbarComponent?
        private var cancelPressed: (() -> Void)?
        private var donePressed: (() -> Void)?
        private var doneLongPressed: ((Any?) -> Void)?
        private var tabPressed: ((TGPhotoEditorTab) -> Void)?

        override init(frame: CGRect) {
            super.init(frame: frame)

            self.clipsToBounds = false
            self.addSubview(self.buttonsBackgroundView)

            self.selectionView.backgroundColor = UIColor(rgb: 0xffffff, alpha: 0.15)
            self.selectionView.isUserInteractionEnabled = false
            self.selectionView.alpha = 0.0

            self.infoLabel.backgroundColor = .clear
            self.infoLabel.textAlignment = .center
            self.infoLabel.textColor = .white
            self.infoLabel.font = Font.regular(13.0)
            self.infoLabel.isUserInteractionEnabled = false
            self.addSubview(self.infoLabel)

            self.doneButtonContextView.beginDelay = 0.4
            self.doneButtonContextView.activated = { [weak self] gesture, _ in
                guard let self else {
                    gesture.cancel()
                    return
                }
                self.doneLongPressed?(self.doneButtonContextView)
            }
            self.doneButtonContextView.shouldBegin = { [weak self] _ in
                guard let self, let component = self.component else {
                    return false
                }
                return self.doneLongPressed != nil && component.doneButtonEnabled && !component.cancelDoneButtonsHidden && !component.allButtonsHidden
            }
        }

        required init?(coder: NSCoder) {
            preconditionFailure()
        }

        fileprivate var cancelButtonFrame: CGRect {
            return self.cancelButton.view?.frame ?? .zero
        }

        fileprivate var doneButtonFrame: CGRect {
            return self.doneButtonContextView.frame
        }

        fileprivate var doneButtonSourceView: UIView {
            return self.doneButtonContextView
        }

        fileprivate func viewForTab(_ tab: TGPhotoEditorTab) -> UIView? {
            return self.centerButtonViews[tab.rawValue]?.view
        }

        func update(component: MediaPickerPhotoToolbarComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
            self.component = component
            self.cancelPressed = component.cancelPressed
            self.donePressed = component.donePressed
            self.doneLongPressed = component.doneLongPressed
            self.tabPressed = component.tabPressed

            //let presentationData = component.context.sharedContext.currentPresentationData.with { $0 }
            let accentColor = UIColor(rgb: 0xffd300) //presentationData.theme.list.itemAccentColor
            let selectedIconColor = UIColor.white //(rgb: 0xffd300)

            self.backgroundColor = .clear //component.solidBackground ? UIColor(rgb: 0x000000, alpha: 0.55) : .clear

            let cancelSize = self.cancelButton.update(
                transition: transition,
                component: AnyComponent(
                    GlassBarButtonComponent(
                        size: CGSize(width: toolbarButtonSide, height: toolbarButtonSide),
                        backgroundColor: nil,
                        isDark: true,
                        state: .glass,
                        isEnabled: !component.cancelDoneButtonsHidden && !component.allButtonsHidden,
                        isVisible: true,
                        component: AnyComponentWithIdentity(
                            id: "close",
                            component: AnyComponent(
                                BundleIconComponent(
                                    name: component.backButtonType == TGPhotoEditorBackButtonBack ? "Navigation/Back" : "Navigation/Close",
                                    tintColor: .white
                                )
                            )
                        ),
                        action: { [weak self] _ in
                            self?.cancelPressed?()
                        }
                    )
                ),
                environment: {},
                containerSize: CGSize(width: toolbarButtonSide, height: toolbarButtonSide)
            )

            let doneIconName: String
            let doneBackgroundColor: UIColor? = UIColor(rgb: 0x0088ff)
            var doneWidth: CGFloat = toolbarButtonSide
            switch component.doneButtonType {
            case TGPhotoEditorDoneButtonSend:
                doneIconName = "Media Editor/Send"
                doneWidth = 46.0
            case TGPhotoEditorDoneButtonSchedule:
                doneIconName = "Chat/Input/ScheduleIcon"
                doneWidth = 46.0
            case TGPhotoEditorDoneButtonDone:
                doneIconName = "Navigation/Done"
            default:
                doneIconName = "Navigation/Done"
            }
            
            let doneSize = self.doneButton.update(
                transition: transition,
                component: AnyComponent(
                    GlassBarButtonComponent(
                        size: CGSize(width: doneWidth, height: toolbarButtonSide),
                        backgroundColor: doneBackgroundColor,
                        isDark: true,
                        state: doneBackgroundColor != nil ? .tintedGlass : .glass,
                        isEnabled: component.doneButtonEnabled && !component.cancelDoneButtonsHidden && !component.allButtonsHidden,
                        isVisible: true,
                        component: AnyComponentWithIdentity(
                            id: "done",
                            component: AnyComponent(
                                BundleIconComponent(
                                    name: doneIconName,
                                    tintColor: .white
                                )
                            )
                        ),
                        action: { [weak self] _ in
                            self?.donePressed?()
                        }
                    )
                ),
                environment: {},
                containerSize: CGSize(width: doneWidth, height: toolbarButtonSide)
            )
            
//            let doneContent: AnyComponentWithIdentity<Empty>
//            let doneFixedSize: CGSize?
//            let doneAvailableSize: CGSize
//            if component.hasSendStarsButton {
//                let text = "\u{2b50}\u{fe0f} \(component.sendPaidMessageStars)"
//                doneContent = AnyComponentWithIdentity(
//                    id: "stars-\(component.sendPaidMessageStars)",
//                    component: AnyComponent(Text(text: text, font: Font.with(size: 17.0, design: .round, weight: .semibold, traits: .monospacedNumbers), color: .white))
//                )
//                doneFixedSize = nil
//                doneAvailableSize = CGSize(width: 180.0, height: toolbarSideButtonSide)
//            } else {
//                doneContent = self.sideButtonContent(iconName: self.doneIconName(component.doneButtonType), color: .white, id: "done-\(component.doneButtonType.rawValue)")
//                doneFixedSize = CGSize(width: toolbarSideButtonSide, height: toolbarSideButtonSide)
//                doneAvailableSize = CGSize(width: toolbarSideButtonSide, height: toolbarSideButtonSide)
//            }
//            let doneSize = self.doneButton.update(
//                content: doneContent,
//                fixedSize: doneFixedSize,
//                availableSize: doneAvailableSize,
//                isEnabled: component.doneButtonEnabled && !component.cancelDoneButtonsHidden && !component.allButtonsHidden,
//                transition: transition
//            )

            let sideAlpha = component.allButtonsHidden ? 0.0 : 1.0
            let sideFrames = self.sideButtonFrames(availableSize: availableSize, cancelSize: cancelSize, doneSize: doneSize, component: component)
            if let cancelButtonView = self.cancelButton.view {
                if cancelButtonView.superview == nil {
                    self.addSubview(cancelButtonView)
                }
                transition.setAlpha(view: cancelButtonView, alpha: sideAlpha)
                transition.setFrame(view: cancelButtonView, frame: sideFrames.cancel)
            }
            if let doneButtonView = self.doneButton.view {
                if self.doneButtonContextView.superview == nil {
                    self.addSubview(self.doneButtonContextView)
                }
                if doneButtonView.superview !== self.doneButtonContextView {
                    self.doneButtonContextView.addSubview(doneButtonView)
                }
                self.doneButtonContextView.targetViewForActivationProgress = doneButtonView
                self.doneButtonContextView.isGestureEnabled = component.doneLongPressed != nil && component.doneButtonEnabled && !component.cancelDoneButtonsHidden && !component.allButtonsHidden
                transition.setAlpha(view: self.doneButtonContextView, alpha: sideAlpha * (component.doneButtonEnabled ? 1.0 : 0.2))
                transition.setFrame(view: self.doneButtonContextView, frame: sideFrames.done)
                transition.setFrame(view: doneButtonView, frame: CGRect(origin: .zero, size: sideFrames.done.size))
            }

            self.updateCenterButtons(
                component: component,
                availableSize: availableSize,
                doneSize: doneSize,
                selectedIconColor: selectedIconColor,
                accentColor: accentColor,
                transition: transition
            )

            self.updateInfoLabel(component: component, availableSize: availableSize, transition: transition)

            return availableSize
        }

        private func doneIconName(_ type: TGPhotoEditorDoneButton) -> String {
            switch type.rawValue {
            case 1:
                return "Editor/Commit"
            case 2:
                return "Editor/Commit"
            case 3:
                return "PhotoPickerSendIcon"
            default:
                return "PhotoPickerSendIcon"
            }
        }

        private func sideButtonFrames(availableSize: CGSize, cancelSize: CGSize, doneSize: CGSize, component: MediaPickerPhotoToolbarComponent) -> (cancel: CGRect, done: CGRect) {
            let sideInset: CGFloat = 26.0
            if availableSize.width > availableSize.height {
                let cancelFrame = CGRect(origin: CGPoint(x: sideInset, y: 0.0), size: cancelSize)
                let doneFrame: CGRect
                if component.hasSendStarsButton {
                    doneFrame = CGRect(x: availableSize.width - doneSize.width - 2.0, y: 0.0, width: doneSize.width, height: doneSize.height)
                } else {
                    doneFrame = CGRect(x: availableSize.width - doneSize.width - sideInset, y: 0.0, width: doneSize.width, height: doneSize.height)
                }
                return (cancelFrame, doneFrame)
            } else {
                let offset: CGFloat = component.interfaceOrientation == .landscapeLeft ? availableSize.width - toolbarSideButtonSide : 0.0
                let cancelFrame = CGRect(x: offset, y: availableSize.height - toolbarSideButtonSide, width: toolbarSideButtonSide, height: toolbarSideButtonSide)
                let doneFrame = CGRect(x: offset, y: 0.0, width: toolbarSideButtonSide, height: toolbarSideButtonSide)
                return (cancelFrame, doneFrame)
            }
        }

        private func updateCenterButtons(component: MediaPickerPhotoToolbarComponent, availableSize: CGSize, doneSize: CGSize, selectedIconColor: UIColor, accentColor: UIColor, transition: ComponentTransition) {
            let tabs = toolbarTabOrder.filter { component.currentTabs.contains($0) }
            let visibleRawValues = Set(tabs.map { $0.rawValue })

            for (rawValue, buttonView) in Array(self.centerButtonViews) {
                if !visibleRawValues.contains(rawValue) {
                    if let view = buttonView.view {
                        transition.setAlpha(view: view, alpha: 0.0, completion: { _ in
                            view.removeFromSuperview()
                        })
                    }
                    self.centerButtonViews.removeValue(forKey: rawValue)
                }
            }

            guard !tabs.isEmpty else {
                transition.setAlpha(view: self.buttonsBackgroundView, alpha: 0.0)
                transition.setAlpha(view: self.selectionView, alpha: 0.0)
                self.buttonsBackgroundView.isUserInteractionEnabled = false
                return
            }

            let buttonFrames = self.centerButtonFrames(tabs: tabs, availableSize: availableSize, doneSize: doneSize, component: component)
            var backgroundFrame = CGRect.null
            for tab in tabs {
                if let frame = buttonFrames[tab.rawValue] {
                    backgroundFrame = backgroundFrame.union(frame)
                }
            }
            if backgroundFrame.isNull {
                transition.setAlpha(view: self.buttonsBackgroundView, alpha: 0.0)
                transition.setAlpha(view: self.selectionView, alpha: 0.0)
                self.buttonsBackgroundView.isUserInteractionEnabled = false
                return
            }
            backgroundFrame = CGRect(
                x: floorToScreenPixels(backgroundFrame.minX),
                y: floorToScreenPixels(backgroundFrame.minY),
                width: ceil(backgroundFrame.width),
                height: ceil(backgroundFrame.height)
            )

            let centerHidden = component.allButtonsHidden || component.centerButtonsHidden || component.editButtonsHidden
            let centerAlpha: CGFloat = centerHidden ? 0.0 : (component.editButtonsEnabled ? 1.0 : 0.2)
            self.buttonsBackgroundView.isUserInteractionEnabled = !centerHidden && component.editButtonsEnabled
            transition.setAlpha(view: self.buttonsBackgroundView, alpha: centerAlpha)
            transition.setFrame(view: self.buttonsBackgroundView, frame: backgroundFrame)
            
            let minSide = min(backgroundFrame.width, backgroundFrame.height)
            self.buttonsBackgroundView.update(size: backgroundFrame.size, cornerRadius: minSide * 0.5, isDark: true, tintColor: .init(kind: .panel), isInteractive: true, isVisible: !centerHidden, transition: transition)

            if self.selectionView.superview == nil {
                self.buttonsBackgroundView.contentView.insertSubview(self.selectionView, at: 0)
            } else {
                self.buttonsBackgroundView.contentView.sendSubviewToBack(self.selectionView)
            }

            var selectionFrame: CGRect?

            for tab in tabs {
                guard let buttonFrame = buttonFrames[tab.rawValue] else {
                    continue
                }

                let rawValue = tab.rawValue
                let buttonView: ComponentView<Empty>
                if let current = self.centerButtonViews[rawValue] {
                    buttonView = current
                } else {
                    buttonView = ComponentView<Empty>()
                    self.centerButtonViews[rawValue] = buttonView
                }

                let isDisabled = component.disabledTabs.contains(tab)
                let isHighlighted = component.highlightedTabs.contains(tab)
                let selectedVisual = component.activeTab == tab && !dontHighlightOnSelectionTabs.contains(rawValue)
                let iconColor: UIColor
                if selectedVisual {
                    iconColor = selectedIconColor
                } else if isHighlighted && !isDisabled {
                    iconColor = accentColor
                } else {
                    iconColor = .white
                }

                let content: AnyComponent<Empty>
                switch tab {
                case .qualityTab:
                    content = AnyComponent(
                        Image(
                            image: self.imageCache.qualityIcon(
                                isPhoto: component.qualityIsPhoto,
                                highQuality: component.qualityHighQuality,
                                preset: component.qualityPreset,
                                color: iconColor
                            ),
                            size: CGSize(width: 28.0, height: 22.0),
                            contentMode: .center
                        )
                    )
                case .timerTab:
                    content = AnyComponent(
                        Image(
                            image: self.imageCache.timerIcon(value: component.timerValue, color: iconColor),
                            size: CGSize(width: 24.0, height: 24.0),
                            contentMode: .center
                        )
                    )
                default:
                    content = AnyComponent(
                        BundleIconComponent(
                            name: self.iconName(tab),
                            tintColor: iconColor,
                            maxSize: CGSize(width: 28.0, height: 28.0)
                        )
                    )
                }
                let buttonSize = buttonView.update(
                    transition: transition,
                    component: AnyComponent(
                        PlainButtonComponent(
                            content: content,
                            minSize: CGSize(width: toolbarButtonSide, height: toolbarButtonSide),
                            action: { [weak self] in
                                self?.tabPressed?(tab)
                            },
                            isEnabled: component.editButtonsEnabled && !isDisabled,
                            animateAlpha: true,
                            animateScale: false,
                            animateContents: false
                        )
                    ),
                    environment: {},
                    containerSize: CGSize(width: toolbarButtonSide, height: toolbarButtonSide)
                )

                if let view = buttonView.view {
                    if view.superview == nil {
                        self.buttonsBackgroundView.contentView.addSubview(view)
                    }
                    let localFrame = CGRect(
                        x: buttonFrame.minX - backgroundFrame.minX,
                        y: buttonFrame.minY - backgroundFrame.minY,
                        width: buttonSize.width,
                        height: buttonSize.height
                    )
                    if selectedVisual {
                        let selectionSide = max(0.0, min(backgroundFrame.width, backgroundFrame.height) - 6.0)
                        selectionFrame = CGRect(
                            x: floorToScreenPixels(localFrame.midX - selectionSide / 2.0),
                            y: floorToScreenPixels(localFrame.midY - selectionSide / 2.0),
                            width: selectionSide,
                            height: selectionSide
                        )
                    }
                    transition.setFrame(view: view, frame: localFrame)
                    transition.setAlpha(view: view, alpha: isDisabled ? 0.2 : 1.0)
                }
            }

            if let selectionFrame = selectionFrame {
                self.selectionView.layer.cornerRadius = selectionFrame.width * 0.5
                transition.setFrame(view: self.selectionView, frame: selectionFrame)
                transition.setAlpha(view: self.selectionView, alpha: centerHidden ? 0.0 : 1.0)
            } else {
                transition.setAlpha(view: self.selectionView, alpha: 0.0)
            }
        }

        private func iconName(_ tab: TGPhotoEditorTab) -> String {
            switch tab {
            case .cropTab:
                return "Media Editor/Crop"
            case .toolsTab:
                return "Media Editor/Adjustments"
            case .rotateTab:
                return "Editor/Rotate"
            case .paintTab:
                return "Media Editor/Pencil"
            case .stickerTab:
                return "Media Editor/AddSticker"
            case .textTab:
                return "Media Editor/AddText"
            case .eraserTab:
                return "Editor/Eraser"
            case .mirrorTab:
                return "Media Editor/Mirror"
            case .aspectRatioTab:
                return "Editor/AspectRatio"
            case .tintTab:
                return "Media Editor/Tint"
            case .blurTab:
                return "Media Editor/Blur"
            case .curvesTab:
                return "Media Editor/Curves"
            default:
                return "Media Editor/Crop"
            }
        }

        private func centerButtonFrames(tabs: [TGPhotoEditorTab], availableSize: CGSize, doneSize: CGSize, component: MediaPickerPhotoToolbarComponent) -> [UInt: CGRect] {
            var result: [UInt: CGRect] = [:]
            let count = tabs.count
            guard count != 0 else {
                return result
            }

            let totalLength = CGFloat(count) * toolbarButtonSide + CGFloat(count - 1) * centerButtonSpacing
            let step = toolbarButtonSide + centerButtonSpacing

            if availableSize.width > availableSize.height {
                let leftEdge = toolbarSideButtonSide
                let rightEdge: CGFloat = component.hasSendStarsButton ? doneSize.width + 2.0 : toolbarSideButtonSide
                let availableWidth = availableSize.width - leftEdge - rightEdge
                let startX = floorToScreenPixels(leftEdge + (availableWidth - totalLength) / 2.0)

                for i in 0 ..< count {
                    result[tabs[i].rawValue] = CGRect(
                        x: startX + CGFloat(i) * step,
                        y: 0.0,
                        width: toolbarButtonSide,
                        height: toolbarButtonSide
                    )
                }
            } else {
                let x: CGFloat
                if component.interfaceOrientation == .landscapeLeft {
                    x = availableSize.width - toolbarButtonSide - 8.0
                } else {
                    x = 8.0
                }

                let topInset = toolbarSideButtonSide
                let bottomInset = toolbarSideButtonSide
                let availableHeight = availableSize.height - topInset - bottomInset
                let startY = floorToScreenPixels(topInset + (availableHeight - totalLength) / 2.0)

                for i in 0 ..< count {
                    result[tabs[i].rawValue] = CGRect(
                        x: x,
                        y: startY + CGFloat(i) * step,
                        width: toolbarButtonSide,
                        height: toolbarButtonSide
                    )
                }
            }

            return result
        }

        private func updateInfoLabel(component: MediaPickerPhotoToolbarComponent, availableSize: CGSize, transition: ComponentTransition) {
            self.infoLabel.text = component.infoString
            self.infoLabel.isHidden = component.infoString == nil
            guard component.infoString != nil else {
                return
            }

            if availableSize.width > availableSize.height {
                self.infoLabel.transform = .identity
                transition.setFrame(view: self.infoLabel, frame: CGRect(x: toolbarSideButtonSide + 10.0, y: 0.0, width: availableSize.width - (toolbarSideButtonSide + 10.0) * 2.0, height: toolbarSideButtonSide))
            } else {
                let bounds = CGRect(x: 0.0, y: 0.0, width: availableSize.height - (toolbarSideButtonSide + 10.0) * 2.0, height: availableSize.width)
                self.infoLabel.bounds = bounds
                self.infoLabel.center = CGPoint(x: availableSize.width / 2.0, y: availableSize.height / 2.0)
                if component.interfaceOrientation == .landscapeLeft {
                    self.infoLabel.transform = CGAffineTransform(rotationAngle: .pi / 2.0)
                } else if component.interfaceOrientation == .landscapeRight {
                    self.infoLabel.transform = CGAffineTransform(rotationAngle: -.pi / 2.0)
                } else {
                    self.infoLabel.transform = .identity
                }
            }
        }
    }

    func makeView() -> View {
        return View(frame: .zero)
    }

    func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
    }
}

public func makeMediaPickerPhotoToolbarView(context: AccountContext, backButton: TGPhotoEditorBackButton, doneButton: TGPhotoEditorDoneButton, solidBackground: Bool, hasSendStarsButton: Bool) -> (UIView & TGPhotoToolbarViewProtocol)? {
    return MediaPickerPhotoToolbarView(context: context, backButton: backButton, doneButton: doneButton, solidBackground: solidBackground, hasSendStarsButton: hasSendStarsButton)
}

final class MediaPickerPhotoToolbarView: UIView, TGPhotoToolbarViewProtocol {
    private let context: AccountContext
    private let solidBackground: Bool
    private let hasSendStarsButton: Bool
    private let rootView = ComponentView<Empty>()

    private var transitionedOut = false

    var cancelPressed: (() -> Void)? {
        didSet {
            self.update(transition: .immediate)
        }
    }
    var donePressed: (() -> Void)? {
        didSet {
            self.update(transition: .immediate)
        }
    }
    var doneLongPressed: ((Any?) -> Void)? {
        didSet {
            self.update(transition: .immediate)
        }
    }
    var tabPressed: ((TGPhotoEditorTab) -> Void)? {
        didSet {
            self.update(transition: .immediate)
        }
    }

    var interfaceOrientation: UIInterfaceOrientation = .portrait {
        didSet {
            self.update(transition: .immediate)
        }
    }
    
    var bottomInset: CGFloat = 0.0
    
    var backButtonType: TGPhotoEditorBackButton {
        didSet {
            self.update(transition: .immediate)
        }
    }

    var doneButtonType: TGPhotoEditorDoneButton {
        didSet {
            self.update(transition: .immediate)
        }
    }

    var sendPaidMessageStars: Int64 = 0 {
        didSet {
            self.update(transition: ComponentTransition(animation: .curve(duration: 0.2, curve: .easeInOut)))
        }
    }

    private(set) var currentTabs: TGPhotoEditorTab = []
    private var activeTab: TGPhotoEditorTab = []
    private var highlightedTabs: TGPhotoEditorTab = []
    private var disabledTabs: TGPhotoEditorTab = []
    private var editButtonsHidden = false
    private var editButtonsEnabled = true
    private var centerButtonsHidden = false
    private var allButtonsHidden = false
    private var cancelDoneButtonsHidden = false
    private var doneButtonEnabled = true
    private var qualityIsPhoto = false
    private var qualityHighQuality = false
    private var qualityPreset = 3
    private var timerValue = 0
    private var infoString: String?

    var doneButton: UIView {
        return (self.rootView.view as? MediaPickerPhotoToolbarComponent.View)?.doneButtonSourceView ?? UIView()
    }

    var cancelButtonFrame: CGRect {
        return (self.rootView.view as? MediaPickerPhotoToolbarComponent.View)?.cancelButtonFrame ?? .zero
    }

    var doneButtonFrame: CGRect {
        return (self.rootView.view as? MediaPickerPhotoToolbarComponent.View)?.doneButtonFrame ?? .zero
    }

    init(context: AccountContext, backButton: TGPhotoEditorBackButton, doneButton: TGPhotoEditorDoneButton, solidBackground: Bool, hasSendStarsButton: Bool) {
        self.context = context
        self.backButtonType = backButton
        self.doneButtonType = doneButton
        self.solidBackground = solidBackground
        self.hasSendStarsButton = hasSendStarsButton

        super.init(frame: .zero)

        self.clipsToBounds = false
        self.backgroundColor = .clear
        self.update(transition: .immediate)
    }

    required init?(coder: NSCoder) {
        preconditionFailure()
    }

    override func layoutSubviews() {
        super.layoutSubviews()

        self.update(transition: .immediate)
        self.updateRootFrame(transition: .immediate)
    }

    func transitionIn(animated: Bool) {
        self.transitionIn(animated: animated, transparent: false)
    }

    func transitionIn(animated: Bool, transparent: Bool) {
        self.transitionedOut = false
        self.isHidden = false
        if !transparent {
            self.backgroundColor = UIColor(rgb: 0x000000)
        }

        let transition = animated ? ComponentTransition(animation: .curve(duration: 0.3, curve: .easeInOut)) : .immediate
        self.updateRootFrame(transition: transition)

        if !transparent {
            self.backgroundColor = .clear
        }
    }

    func transitionOut(animated: Bool) {
        self.transitionOut(animated: animated, transparent: false, hideOnCompletion: false)
    }

    func transitionOut(animated: Bool, transparent: Bool, hideOnCompletion: Bool) {
        self.transitionedOut = true
        if !transparent {
            self.backgroundColor = UIColor(rgb: 0x000000)
        }

        let duration: Double = animated ? 0.3 : 0.0
        let transition = animated ? ComponentTransition(animation: .curve(duration: duration, curve: .easeInOut)) : .immediate
        self.updateRootFrame(transition: transition)

        if hideOnCompletion {
            DispatchQueue.main.asyncAfter(deadline: .now() + duration) { [weak self] in
                self?.isHidden = true
            }
        }
    }

    func setDoneButtonEnabled(_ enabled: Bool, animated: Bool) {
        self.doneButtonEnabled = enabled
        self.update(transition: self.transition(animated: animated))
    }

    func setEditButtonsEnabled(_ enabled: Bool, animated: Bool) {
        self.editButtonsEnabled = enabled
        self.update(transition: self.transition(animated: animated))
    }

    func setEditButtonsHidden(_ hidden: Bool, animated: Bool) {
        self.editButtonsHidden = hidden
        self.update(transition: self.transition(animated: animated))
    }

    func setEditButtonsHighlighted(_ buttons: TGPhotoEditorTab) {
        self.highlightedTabs = buttons
        self.update(transition: .immediate)
    }

    func setEditButtonsDisabled(_ buttons: TGPhotoEditorTab) {
        self.disabledTabs = buttons
        self.update(transition: .immediate)
    }

    func setCenterButtonsHidden(_ hidden: Bool, animated: Bool) {
        self.centerButtonsHidden = hidden
        self.update(transition: self.transition(animated: animated))
    }

    func setAllButtonsHidden(_ hidden: Bool, animated: Bool) {
        self.allButtonsHidden = hidden
        self.update(transition: self.transition(animated: animated))
    }

    func setCancelDoneButtonsHidden(_ hidden: Bool, animated: Bool) {
        self.cancelDoneButtonsHidden = hidden
        self.update(transition: self.transition(animated: animated))
    }

    func setToolbarTabs(_ tabs: TGPhotoEditorTab, animated: Bool) {
        self.currentTabs = tabs
        self.update(transition: self.transition(animated: animated))
    }

    func setActiveTab(_ tab: TGPhotoEditorTab) {
        self.activeTab = tab
        self.update(transition: .spring(duration: 0.4))
    }

    func setQualityButtonIsPhoto(_ isPhoto: Bool, highQuality: Bool, videoPreset: Int) {
        self.qualityIsPhoto = isPhoto
        self.qualityHighQuality = highQuality
        self.qualityPreset = videoPreset
        self.update(transition: .immediate)
    }

    func setTimerButtonValue(_ value: Int) {
        self.timerValue = value
        self.update(transition: .immediate)
    }

    func setInfoString(_ string: String?) {
        self.infoString = string
        self.update(transition: .immediate)
    }

    @objc(viewForTab:)
    func view(for tab: TGPhotoEditorTab) -> UIView? {
        return (self.rootView.view as? MediaPickerPhotoToolbarComponent.View)?.viewForTab(tab)
    }

    private func transition(animated: Bool) -> ComponentTransition {
        if animated {
            return ComponentTransition(animation: .curve(duration: 0.2, curve: .easeInOut))
        } else {
            return .immediate
        }
    }

    private func update(transition: ComponentTransition) {
        let size = self.bounds.size
        let _ = self.rootView.update(
            transition: transition,
            component: AnyComponent(
                MediaPickerPhotoToolbarComponent(
                    context: self.context,
                    solidBackground: self.solidBackground,
                    backButtonType: self.backButtonType,
                    doneButtonType: self.doneButtonType,
                    currentTabs: self.currentTabs,
                    activeTab: self.activeTab,
                    highlightedTabs: self.highlightedTabs,
                    disabledTabs: self.disabledTabs,
                    qualityIsPhoto: self.qualityIsPhoto,
                    qualityHighQuality: self.qualityHighQuality,
                    qualityPreset: self.qualityPreset,
                    timerValue: self.timerValue,
                    hasSendStarsButton: self.hasSendStarsButton,
                    sendPaidMessageStars: self.sendPaidMessageStars,
                    editButtonsHidden: self.editButtonsHidden,
                    editButtonsEnabled: self.editButtonsEnabled,
                    centerButtonsHidden: self.centerButtonsHidden,
                    allButtonsHidden: self.allButtonsHidden,
                    cancelDoneButtonsHidden: self.cancelDoneButtonsHidden,
                    doneButtonEnabled: self.doneButtonEnabled,
                    interfaceOrientation: self.interfaceOrientation,
                    bottomInset: self.bottomInset,
                    infoString: self.infoString,
                    cancelPressed: self.cancelPressed,
                    donePressed: self.donePressed,
                    doneLongPressed: self.doneLongPressed,
                    tabPressed: self.tabPressed
                )
            ),
            environment: {},
            forceUpdate: true,
            containerSize: size
        )

        if let view = self.rootView.view {
            if view.superview == nil {
                self.addSubview(view)
            }
            self.updateRootFrame(transition: transition)
        }
    }

    private func updateRootFrame(transition: ComponentTransition) {
        guard let view = self.rootView.view else {
            return
        }

        var frame = CGRect(origin: .zero, size: self.bounds.size)
        if self.transitionedOut {
            if self.bounds.width > self.bounds.height {
                frame.origin.y = self.bounds.height
            } else if self.interfaceOrientation == .landscapeLeft {
                frame.origin.x = -self.bounds.width
            } else {
                frame.origin.x = self.bounds.width
            }
        }
        transition.setFrame(view: view, frame: frame)
    }
}