smart_printer/smart_printer/SettingsView.swift

import Cocoa

// MARK: - Root

final class SettingsView: NSView, AppearanceRefreshable {
    private var aboutCard: SettingsGroupCard!
    private var observers: [NSObjectProtocol] = []

    init() {
        super.init(frame: .zero)
        wantsLayer = true
        layer?.backgroundColor = AppTheme.background.cgColor
        translatesAutoresizingMaskIntoConstraints = false
        setup()
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { nil }

    deinit {
        observers.forEach { NotificationCenter.default.removeObserver($0) }
    }

    func refreshAppearance() {
        layer?.backgroundColor = AppTheme.background.cgColor
    }

    func refreshPremiumState() {
        refreshAboutCard()
    }

    private func setup() {
        let scrollView = NSScrollView()
        scrollView.translatesAutoresizingMaskIntoConstraints = false
        scrollView.hasVerticalScroller = true
        scrollView.autohidesScrollers = true
        scrollView.drawsBackground = false
        scrollView.borderType = .noBorder

        let document = FlippedSettingsDocumentView()
        document.translatesAutoresizingMaskIntoConstraints = false

        let panel = ContentPanelView(cornerRadius: 22)
        panel.translatesAutoresizingMaskIntoConstraints = false

        let stack = NSStackView()
        stack.orientation = .vertical
        stack.alignment = .leading
        stack.spacing = 28
        stack.translatesAutoresizingMaskIntoConstraints = false

        let appSection = makeSection(title: "App", card: makeAppCard())
        aboutCard = makeAboutCard()
        let aboutSection = makeSection(title: "About", card: aboutCard)
        stack.addArrangedSubview(appSection)
        stack.addArrangedSubview(aboutSection)

        observers.append(
            NotificationCenter.default.addObserver(
                forName: .premiumStatusDidChange,
                object: nil,
                queue: .main
            ) { [weak self] _ in
                self?.refreshAboutCard()
            }
        )

        [appSection, aboutSection].forEach { section in
            section.widthAnchor.constraint(equalTo: stack.widthAnchor).isActive = true
        }

        panel.addSubview(stack)
        document.addSubview(panel)
        scrollView.documentView = document
        addSubview(scrollView)

        let guide = scrollView.contentView
        NSLayoutConstraint.activate([
            scrollView.leadingAnchor.constraint(equalTo: leadingAnchor),
            scrollView.trailingAnchor.constraint(equalTo: trailingAnchor),
            scrollView.topAnchor.constraint(equalTo: topAnchor),
            scrollView.bottomAnchor.constraint(equalTo: bottomAnchor),

            document.topAnchor.constraint(equalTo: guide.topAnchor),
            document.leadingAnchor.constraint(equalTo: guide.leadingAnchor),
            document.trailingAnchor.constraint(equalTo: guide.trailingAnchor),
            document.widthAnchor.constraint(equalTo: guide.widthAnchor),

            panel.topAnchor.constraint(equalTo: document.topAnchor, constant: 8),
            panel.leadingAnchor.constraint(equalTo: document.leadingAnchor, constant: 24),
            panel.trailingAnchor.constraint(equalTo: document.trailingAnchor, constant: -24),
            panel.bottomAnchor.constraint(equalTo: document.bottomAnchor, constant: -32),
            panel.widthAnchor.constraint(equalTo: document.widthAnchor, constant: -48),

            stack.leadingAnchor.constraint(equalTo: panel.leadingAnchor, constant: 28),
            stack.trailingAnchor.constraint(equalTo: panel.trailingAnchor, constant: -28),
            stack.topAnchor.constraint(equalTo: panel.topAnchor, constant: 28),
            stack.bottomAnchor.constraint(equalTo: panel.bottomAnchor, constant: -28),
            stack.widthAnchor.constraint(equalTo: panel.widthAnchor, constant: -56),
        ])
    }

    private func makeSection(title: String, card: NSView) -> NSView {
        let container = NSStackView()
        container.orientation = .vertical
        container.alignment = .leading
        container.spacing = 12
        container.translatesAutoresizingMaskIntoConstraints = false

        let label = NSTextField.themeLabel(title, style: .primary, font: AppTheme.semiboldFont(size: 18))
        label.translatesAutoresizingMaskIntoConstraints = false

        container.addArrangedSubview(label)
        container.addArrangedSubview(card)
        card.widthAnchor.constraint(equalTo: container.widthAnchor).isActive = true
        return container
    }

    private func makeAppCard() -> NSView {
        let card = SettingsGroupCard()

        card.addRow(SettingsToggleRow(
            symbolName: "moon.fill",
            title: "Dark Mode",
            isOn: AppSettings.darkModeEnabled,
            isLast: true
        ) { enabled in
            AppSettings.darkModeEnabled = enabled
            AppSettings.applyAppearance()
        })

        return card
    }

    private func makeAboutCard() -> SettingsGroupCard {
        let card = SettingsGroupCard()
        card.setRows(aboutCardRows())
        return card
    }

    private func refreshAboutCard() {
        aboutCard?.setRows(aboutCardRows())
    }

    private func aboutCardRows() -> [NSView] {
        var rows: [NSView] = []

        if StoreManager.shared.isPremium {
            rows.append(SettingsActionRow(symbolName: "star.fill", title: "Rate App") {
                AppRatingManager.shared.requestReviewFromUser(on: NSApp.keyWindow)
            })
        }

        let config = PaywallConfigService.shared.config
        rows.append(SettingsActionRow(symbolName: "arrow.clockwise", title: config.footer.restorePurchase) {
            Task { @MainActor in
                let store = StoreManager.shared
                store.clearPurchaseError()
                let restored = await store.restorePurchases()
                if restored {
                    store.showAlert(
                        title: config.messages.restoreSuccessTitle,
                        message: config.messages.restoreSuccessMessage,
                        on: NSApp.keyWindow
                    )
                } else if let error = store.purchaseError {
                    store.showPurchaseError(error, on: NSApp.keyWindow)
                }
            }
        })

        rows.append(SettingsActionRow(symbolName: "link", title: "Website") {
            NSWorkspace.shared.open(URL(string: "https://sites.google.com/view/smartprinterappmacos/home")!)
        })
        rows.append(SettingsActionRow(symbolName: "questionmark.circle", title: "Support") {
            NSWorkspace.shared.open(URL(string: "https://sites.google.com/view/smartprinterappmacos/get-support")!)
        })
        rows.append(SettingsActionRow(symbolName: "doc.text", title: "Terms of Use") {
            NSWorkspace.shared.open(URL(string: "https://sites.google.com/view/smartprinterappmacos/terms-and-condition")!)
        })
        rows.append(SettingsActionRow(symbolName: "shield", title: "Privacy Policy", isLast: true) {
            NSWorkspace.shared.open(URL(string: "https://sites.google.com/view/smartprinterappmacos/privacy-policy")!)
        })

        return rows
    }
}

private final class SettingsGroupCard: NSView, AppearanceRefreshable {
    private let stack = NSStackView()

    init() {
        super.init(frame: .zero)
        translatesAutoresizingMaskIntoConstraints = false
        wantsLayer = true
        layer?.cornerRadius = 16
        layer?.borderWidth = 1.5
        layer?.masksToBounds = true
        refreshAppearance()

        stack.orientation = .vertical
        stack.spacing = 0
        stack.translatesAutoresizingMaskIntoConstraints = false
        addSubview(stack)

        NSLayoutConstraint.activate([
            stack.leadingAnchor.constraint(equalTo: leadingAnchor),
            stack.trailingAnchor.constraint(equalTo: trailingAnchor),
            stack.topAnchor.constraint(equalTo: topAnchor),
            stack.bottomAnchor.constraint(equalTo: bottomAnchor),
        ])
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { nil }

    func addRow(_ row: NSView) {
        stack.addArrangedSubview(row)
        row.widthAnchor.constraint(equalTo: stack.widthAnchor).isActive = true
    }

    func setRows(_ rows: [NSView]) {
        stack.arrangedSubviews.forEach { row in
            stack.removeArrangedSubview(row)
            row.removeFromSuperview()
        }
        rows.forEach { addRow($0) }
    }

    func refreshAppearance() {
        layer?.backgroundColor = AppTheme.groupCardBackground.cgColor
        layer?.borderColor = AppTheme.paywallBorder.cgColor
    }
}

// MARK: - Icon

private final class SettingsIconBadge: NSView, AppearanceRefreshable {
    init(symbolName: String) {
        super.init(frame: .zero)
        translatesAutoresizingMaskIntoConstraints = false
        wantsLayer = true
        layer?.cornerRadius = 10
        refreshAppearance()

        let icon = NSImageView()
        icon.translatesAutoresizingMaskIntoConstraints = false
        if let image = NSImage(systemSymbolName: symbolName, accessibilityDescription: nil) {
            let config = NSImage.SymbolConfiguration(pointSize: 15, weight: .medium)
            icon.image = image.withSymbolConfiguration(config)
        }
        icon.contentTintColor = AppTheme.blue
        addSubview(icon)

        NSLayoutConstraint.activate([
            widthAnchor.constraint(equalToConstant: 36),
            heightAnchor.constraint(equalToConstant: 36),
            icon.centerXAnchor.constraint(equalTo: centerXAnchor),
            icon.centerYAnchor.constraint(equalTo: centerYAnchor),
            icon.widthAnchor.constraint(equalToConstant: 18),
            icon.heightAnchor.constraint(equalToConstant: 18),
        ])
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { nil }

    func refreshAppearance() {
        layer?.backgroundColor = AppTheme.blueLight.cgColor
    }
}

// MARK: - Rows

private class SettingsRowBase: NSView, AppearanceRefreshable {
    private var hoverTracker: HoverTracker?
    private var isHovered = false
    private let isInteractive: Bool

    init(isLast: Bool, isInteractive: Bool = false) {
        self.isInteractive = isInteractive
        super.init(frame: .zero)
        translatesAutoresizingMaskIntoConstraints = false
        heightAnchor.constraint(equalToConstant: 56).isActive = true
        if !isLast { addDivider() }

        if isInteractive {
            wantsLayer = true
            hoverTracker = HoverTracker(view: self) { [weak self] hovering in
                self?.setHovered(hovering)
            }
        }
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { nil }

    func refreshAppearance() {
        updateHoverAppearance()
    }

    private func setHovered(_ hovering: Bool) {
        isHovered = hovering
        updateHoverAppearance()
    }

    private func updateHoverAppearance() {
        guard isInteractive else { return }
        animateHover {
            layer?.backgroundColor = (isHovered ? AppTheme.sidebarHoverBackground : .clear).cgColor
        }
    }

    func addDivider() {
        let divider = NSBox()
        divider.boxType = .separator
        divider.translatesAutoresizingMaskIntoConstraints = false
        addSubview(divider)
        NSLayoutConstraint.activate([
            divider.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 60),
            divider.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -16),
            divider.bottomAnchor.constraint(equalTo: bottomAnchor),
            divider.heightAnchor.constraint(equalToConstant: 1),
        ])
    }

    func install(icon symbolName: String, title: String, trailing: NSView) -> NSTextField {
        let badge = SettingsIconBadge(symbolName: symbolName)
        let titleLabel = NSTextField.themeLabel(title, style: .primary, font: AppTheme.mediumFont(size: 15))
        titleLabel.translatesAutoresizingMaskIntoConstraints = false
        trailing.translatesAutoresizingMaskIntoConstraints = false

        addSubview(badge)
        addSubview(titleLabel)
        addSubview(trailing)

        NSLayoutConstraint.activate([
            badge.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 14),
            badge.centerYAnchor.constraint(equalTo: centerYAnchor),

            titleLabel.leadingAnchor.constraint(equalTo: badge.trailingAnchor, constant: 14),
            titleLabel.centerYAnchor.constraint(equalTo: centerYAnchor),

            trailing.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -16),
            trailing.centerYAnchor.constraint(equalTo: centerYAnchor),
            titleLabel.trailingAnchor.constraint(lessThanOrEqualTo: trailing.leadingAnchor, constant: -12),
        ])

        return titleLabel
    }
}

private final class SettingsActionRow: SettingsRowBase {
    init(symbolName: String, title: String, isLast: Bool = false, action: @escaping () -> Void) {
        super.init(isLast: isLast, isInteractive: true)

        let badge = SettingsIconBadge(symbolName: symbolName)
        let titleLabel = NSTextField.themeLabel(title, style: .primary, font: AppTheme.mediumFont(size: 15))
        titleLabel.translatesAutoresizingMaskIntoConstraints = false

        addSubview(badge)
        addSubview(titleLabel)

        NSLayoutConstraint.activate([
            badge.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 14),
            badge.centerYAnchor.constraint(equalTo: centerYAnchor),
            titleLabel.leadingAnchor.constraint(equalTo: badge.trailingAnchor, constant: 14),
            titleLabel.centerYAnchor.constraint(equalTo: centerYAnchor),
            titleLabel.trailingAnchor.constraint(lessThanOrEqualTo: trailingAnchor, constant: -16),
        ])

        let control = LinkControl(onActivate: action)
        control.translatesAutoresizingMaskIntoConstraints = false
        addSubview(control)
        NSLayoutConstraint.activate([
            control.leadingAnchor.constraint(equalTo: leadingAnchor),
            control.trailingAnchor.constraint(equalTo: trailingAnchor),
            control.topAnchor.constraint(equalTo: topAnchor),
            control.bottomAnchor.constraint(equalTo: bottomAnchor),
        ])
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { nil }
}

private final class SettingsPopupRow: SettingsRowBase {
    private let popupTarget: PopupTarget

    init(symbolName: String, title: String, options: [String], selection: String, isLast: Bool = false, onChange: @escaping (String) -> Void) {
        popupTarget = PopupTarget(handler: onChange)
        super.init(isLast: isLast, isInteractive: true)

        let popup = NSPopUpButton()
        popup.bezelStyle = .rounded
        popup.addItems(withTitles: options)
        popup.selectItem(withTitle: selection)
        popup.font = AppTheme.regularFont(size: 13)
        popup.target = popupTarget
        popup.action = #selector(PopupTarget.changed(_:))

        _ = install(icon: symbolName, title: title, trailing: popup)
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { nil }
}

private final class SettingsToggleRow: SettingsRowBase {
    private let toggleTarget: ToggleTarget

    init(symbolName: String, title: String, isOn: Bool, isLast: Bool = false, onChange: @escaping (Bool) -> Void) {
        toggleTarget = ToggleTarget(handler: onChange)
        super.init(isLast: isLast, isInteractive: true)

        let toggle = NSSwitch()
        toggle.state = isOn ? .on : .off
        toggle.target = toggleTarget
        toggle.action = #selector(ToggleTarget.changed(_:))

        _ = install(icon: symbolName, title: title, trailing: toggle)
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { nil }
}

// MARK: - Helpers

private final class LinkControl: NSControl {
    private let onActivate: () -> Void

    init(onActivate: @escaping () -> Void) {
        self.onActivate = onActivate
        super.init(frame: .zero)
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { nil }

    override func mouseUp(with event: NSEvent) {
        guard bounds.contains(convert(event.locationInWindow, from: nil)) else { return }
        onActivate()
    }

    override func resetCursorRects() {
        addCursorRect(bounds, cursor: .pointingHand)
    }
}

private final class PopupTarget: NSObject {
    private let handler: (String) -> Void

    init(handler: @escaping (String) -> Void) {
        self.handler = handler
    }

    @objc func changed(_ sender: NSPopUpButton) {
        handler(sender.titleOfSelectedItem ?? "")
    }
}

private final class ToggleTarget: NSObject {
    private let handler: (Bool) -> Void

    init(handler: @escaping (Bool) -> Void) {
        self.handler = handler
    }

    @objc func changed(_ sender: NSSwitch) {
        handler(sender.state == .on)
    }
}

private final class FlippedSettingsDocumentView: NSView {
    override var isFlipped: Bool { true }
}