StatusBarController.swift

import AppKit
import Foundation

struct ClockDefinition {
    let flag: String
    let city: String
    let timeZoneIdentifier: String

    var timeZone: TimeZone? {
        TimeZone(identifier: timeZoneIdentifier)
    }
}

final class ClockMenuItemView: NSView {
    private static let itemWidth: CGFloat = 320
    private static let zoneColumnWidth: CGFloat = 150
    private static let offsetColumnWidth: CGFloat = 52
    private static let dateColumnWidth: CGFloat = 88
    private static let horizontalPadding: CGFloat = 16
    private static let verticalPadding: CGFloat = 7

    private let titleLabel = NSTextField(labelWithString: "")
    private let timeLabel = NSTextField(labelWithString: "")
    private let zoneLabel = NSTextField(labelWithString: "")
    private let offsetLabel = NSTextField(labelWithString: "")
    private let dateLabel = NSTextField(labelWithString: "")

    init(title: String, time: String, zone: String, offset: String, date: String) {
        super.init(frame: NSRect(x: 0, y: 0, width: Self.itemWidth, height: 48))
        translatesAutoresizingMaskIntoConstraints = false

        titleLabel.stringValue = title
        titleLabel.font = .systemFont(ofSize: 13, weight: .semibold)
        titleLabel.textColor = .labelColor

        timeLabel.stringValue = time
        timeLabel.font = .monospacedDigitSystemFont(ofSize: 13, weight: .semibold)
        timeLabel.textColor = .labelColor
        timeLabel.alignment = .right

        zoneLabel.stringValue = zone
        zoneLabel.font = .systemFont(ofSize: 11)
        zoneLabel.textColor = .secondaryLabelColor
        zoneLabel.lineBreakMode = .byTruncatingMiddle
        zoneLabel.alignment = .left

        offsetLabel.stringValue = offset
        offsetLabel.font = .monospacedDigitSystemFont(ofSize: 11, weight: .regular)
        offsetLabel.textColor = .secondaryLabelColor
        offsetLabel.alignment = .left

        dateLabel.stringValue = date
        dateLabel.font = .systemFont(ofSize: 11)
        dateLabel.textColor = .secondaryLabelColor
        dateLabel.alignment = .left

        let topRow = NSStackView(views: [titleLabel, NSView(), timeLabel])
        topRow.orientation = .horizontal
        topRow.alignment = .centerY

        let bottomRow = NSStackView(views: [zoneLabel, offsetLabel, dateLabel])
        bottomRow.orientation = .horizontal
        bottomRow.alignment = .centerY
        bottomRow.spacing = 10

        let stack = NSStackView(views: [topRow, bottomRow])
        stack.orientation = .vertical
        stack.alignment = .leading
        stack.spacing = 3
        stack.translatesAutoresizingMaskIntoConstraints = false

        addSubview(stack)

        NSLayoutConstraint.activate([
            widthAnchor.constraint(equalToConstant: Self.itemWidth),
            heightAnchor.constraint(equalToConstant: 48),
            stack.leadingAnchor.constraint(equalTo: leadingAnchor, constant: Self.horizontalPadding),
            stack.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -Self.horizontalPadding),
            stack.topAnchor.constraint(equalTo: topAnchor, constant: Self.verticalPadding),
            stack.bottomAnchor.constraint(equalTo: bottomAnchor, constant: -Self.verticalPadding),
            zoneLabel.widthAnchor.constraint(equalToConstant: Self.zoneColumnWidth),
            offsetLabel.widthAnchor.constraint(equalToConstant: Self.offsetColumnWidth),
            dateLabel.widthAnchor.constraint(equalToConstant: Self.dateColumnWidth),
        ])

        zoneLabel.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
        zoneLabel.setContentHuggingPriority(.defaultLow, for: .horizontal)
        offsetLabel.setContentCompressionResistancePriority(.required, for: .horizontal)
        offsetLabel.setContentHuggingPriority(.required, for: .horizontal)
        dateLabel.setContentCompressionResistancePriority(.required, for: .horizontal)
        dateLabel.setContentHuggingPriority(.required, for: .horizontal)
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    var dateText: String {
        dateLabel.stringValue
    }
}

@MainActor
final class StatusBarController {
    private let statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
    private var preferencesDidChangeObserver: NSObjectProtocol?
    private var refreshTimer: Timer?
    private let preferences: AppPreferences
    private let openSettings: () -> Void
    private var analogClockView: AnalogClockStatusView?

    private let clocks: [ClockDefinition] = [
        ClockDefinition(flag: "🇺🇸", city: "San Francisco", timeZoneIdentifier: "America/Los_Angeles"),
        ClockDefinition(flag: "🇺🇸", city: "New York", timeZoneIdentifier: "America/New_York"),
        ClockDefinition(flag: "🇬🇧", city: "London", timeZoneIdentifier: "Europe/London"),
        ClockDefinition(flag: "🇩🇪", city: "Berlin", timeZoneIdentifier: "Europe/Berlin"),
        ClockDefinition(flag: "🇨🇳", city: "Shanghai", timeZoneIdentifier: "Asia/Shanghai"),
        ClockDefinition(flag: "🇯🇵", city: "Tokyo", timeZoneIdentifier: "Asia/Tokyo"),
        ClockDefinition(flag: "🇦🇺", city: "Sydney", timeZoneIdentifier: "Australia/Sydney"),
    ]

    private let timeFormatter: DateFormatter = {
        let formatter = DateFormatter()
        formatter.locale = Locale.autoupdatingCurrent
        formatter.dateFormat = "HH:mm:ss"
        return formatter
    }()

    init(preferences: AppPreferences, openSettings: @escaping () -> Void) {
        self.preferences = preferences
        self.openSettings = openSettings
    }

    var footerViewForTesting: MenuFooterView? {
        statusItem.menu?.items.last?.view as? MenuFooterView
    }

    var renderedMenuDatesForTesting: [String] {
        statusItem.menu?.items.compactMap { ($0.view as? ClockMenuItemView)?.dateText } ?? []
    }

    var statusButtonTitleForTesting: String? {
        statusItem.button?.attributedTitle.string
    }

    var analogClockViewForTesting: AnalogClockStatusView? {
        analogClockView
    }

    deinit {
        refreshTimer?.invalidate()

        if let preferencesDidChangeObserver {
            NotificationCenter.default.removeObserver(preferencesDidChangeObserver)
        }
    }

    func start() {
        configureButton()
        observePreferences()
        rebuildMenu()
        scheduleRefreshTimer()
    }

    private func configureButton() {
        guard let button = statusItem.button else {
            return
        }

        button.image = nil
        button.imagePosition = .noImage
        button.toolTip = "World clocks"
    }

    private func observePreferences() {
        preferencesDidChangeObserver = NotificationCenter.default.addObserver(
            forName: .appPreferencesDidChange,
            object: nil,
            queue: .main
        ) { [weak self] _ in
            Task { @MainActor [weak self] in
                self?.rebuildMenu()
            }
        }
    }

    private func scheduleRefreshTimer() {
        refreshTimer?.invalidate()
        refreshTimer = Timer.scheduledTimer(
            withTimeInterval: 1,
            repeats: true
        ) { [weak self] _ in
            Task { @MainActor [weak self] in
                self?.rebuildMenu()
            }
        }

        if let refreshTimer {
            RunLoop.main.add(refreshTimer, forMode: .common)
        }
    }

    private func rebuildMenu() {
        let now = Date()
        updateStatusItem(for: now)

        let menu = NSMenu()
        menu.autoenablesItems = false

        if let localTimeZone = TimeZone.current as TimeZone? {
            menu.addItem(
                menuItem(
                    flag: localFlagEmoji(),
                    label: "Local",
                    in: localTimeZone,
                    date: now
                )
            )
            menu.addItem(.separator())
        }

        for clock in clocks {
            guard let timeZone = clock.timeZone else {
                continue
            }

            menu.addItem(menuItem(flag: clock.flag, label: clock.city, in: timeZone, date: now))
        }

        menu.addItem(.separator())

        let footerItem = NSMenuItem(title: "", action: nil, keyEquivalent: "")
        footerItem.view = MenuFooterView(
            onQuit: { [weak self] in
                self?.quit()
            },
            onSettings: { [weak self] in
                self?.openSettingsFromMenu()
            }
        )
        menu.addItem(footerItem)

        statusItem.menu = menu
    }

    private func updateStatusItem(for date: Date) {
        guard let button = statusItem.button else {
            return
        }

        switch preferences.clockStyle {
        case .digital:
            statusItem.length = NSStatusItem.variableLength
            removeAnalogClockView(from: button)

            let title = ClockDisplayFormatter(locale: ClockDisplayFormatter.systemLocale()).digitalTitle(
                for: date,
                timeZone: .current,
                showsDate: preferences.showsMenuBarDate,
                showsWeekday: preferences.showsMenuBarWeekday,
                showsSeconds: preferences.showsSecondsInMenuBar,
                blinksSeparator: preferences.blinksTimeSeparator
            )

            button.attributedTitle = NSAttributedString(
                string: title,
                attributes: [
                    .font: NSFont.monospacedDigitSystemFont(ofSize: 12, weight: .medium),
                ]
            )
        case .analog:
            statusItem.length = 30
            button.attributedTitle = NSAttributedString(string: "")
            ensureAnalogClockView(in: button).update(date: date, timeZone: .current)
        }
    }

    private func ensureAnalogClockView(in button: NSStatusBarButton) -> AnalogClockStatusView {
        if let analogClockView {
            return analogClockView
        }

        let view = AnalogClockStatusView(frame: .zero)
        view.translatesAutoresizingMaskIntoConstraints = false
        button.addSubview(view)

        NSLayoutConstraint.activate([
            view.centerXAnchor.constraint(equalTo: button.centerXAnchor),
            view.centerYAnchor.constraint(equalTo: button.centerYAnchor),
            view.widthAnchor.constraint(equalToConstant: 22),
            view.heightAnchor.constraint(equalToConstant: 22),
        ])

        analogClockView = view
        return view
    }

    private func removeAnalogClockView(from button: NSStatusBarButton) {
        analogClockView?.removeFromSuperview()
        analogClockView = nil
        button.subviews
            .compactMap { $0 as? AnalogClockStatusView }
            .forEach { $0.removeFromSuperview() }
    }

    private func menuItem(flag: String, label: String, in timeZone: TimeZone, date: Date) -> NSMenuItem {
        let time = formattedTime(for: date, in: timeZone)
        let zone = displayName(for: timeZone, label: label)
        let offset = formattedOffset(for: timeZone, date: date)
        let dateText = formattedDate(for: date, in: timeZone)
        let title = "\(flag) \(label)"

        let item = NSMenuItem(title: title, action: nil, keyEquivalent: "")
        item.view = ClockMenuItemView(
            title: title,
            time: time,
            zone: zone,
            offset: offset,
            date: dateText
        )
        return item
    }

    private func localFlagEmoji() -> String {
        guard let regionCode = Locale.autoupdatingCurrent.region?.identifier else {
            return "🏠"
        }

        return flagEmoji(for: regionCode) ?? "🏠"
    }

    private func flagEmoji(for regionCode: String) -> String? {
        guard regionCode.count == 2 else {
            return nil
        }

        let scalars = regionCode.uppercased().unicodeScalars.compactMap { scalar -> UnicodeScalar? in
            guard let regionalScalar = UnicodeScalar(127397 + scalar.value) else {
                return nil
            }

            return regionalScalar
        }

        guard scalars.count == 2 else {
            return nil
        }

        return String(String.UnicodeScalarView(scalars))
    }

    private func displayName(for timeZone: TimeZone, label: String) -> String {
        if label == "Local" {
            return timeZone.identifier
        }

        return timeZone.identifier.replacingOccurrences(of: "_", with: " ")
    }

    private func formattedTime(for date: Date, in timeZone: TimeZone) -> String {
        timeFormatter.timeZone = timeZone
        return timeFormatter.string(from: date)
    }

    private func formattedDate(for date: Date, in timeZone: TimeZone) -> String {
        preferences.menuDateFormat.string(
            from: date,
            in: timeZone,
            locale: ClockDisplayFormatter.systemLocale()
        )
    }

    private func formattedOffset(for timeZone: TimeZone, date: Date) -> String {
        let totalMinutes = timeZone.secondsFromGMT(for: date) / 60
        let hours = totalMinutes / 60
        let minutes = abs(totalMinutes % 60)
        let sign = hours >= 0 ? "+" : "-"
        let absoluteHours = abs(hours)

        if minutes == 0 {
            return "UTC\(sign)\(absoluteHours)"
        }

        return String(format: "UTC%@%d:%02d", sign, absoluteHours, minutes)
    }

    @objc
    private func quit() {
        NSApplication.shared.terminate(nil)
    }

    private func openSettingsFromMenu() {
        statusItem.menu?.cancelTracking()
        DispatchQueue.main.async { [openSettings] in
            openSettings()
        }
    }
}