Skip to content

Open source CapCut alternative.

TypeScript
15.0 KB
Raw Blame
#if os(iOS)
import Charts
import DonkeyKitModels
import SwiftUI

/// The super-user dashboard: the nightly rollup as a stat grid and borderless
/// chart sections, opened from the avatar menu. Only operators see it, so its
/// words stay English.
public struct AnalyticsScreen: View {
    var analytics: AnalyticsModel
    @Environment(\.dismiss) private var dismiss

    public init(analytics: AnalyticsModel) {
        self.analytics = analytics
    }

    public var body: some View {
        NavigationStack {
            Group {
                switch analytics.state {
                case .loading:
                    ProgressView()
                        .frame(maxWidth: .infinity, maxHeight: .infinity)
                case .empty:
                    EmptyState(
                        title: "No data yet",
                        message: "The nightly analytics job hasn't produced a rollup."
                    )
                case .failed(let reason):
                    EmptyState(
                        title: "Couldn't load analytics",
                        message: reason,
                        actionTitle: "Retry"
                    ) {
                        Task { await analytics.refresh() }
                    }
                case .loaded(let summary):
                    SummaryList(analytics: analytics, summary: summary)
                        .refreshable { await analytics.refresh() }
                }
            }
            .navigationTitle(Text(verbatim: "Analytics"))
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    Button { dismiss() } label: { Text(verbatim: "Done") }
                        .fontWeight(.semibold)
                }
            }
        }
        .task { await analytics.refresh() }
    }
}

private struct SummaryList: View {
    var analytics: AnalyticsModel
    let summary: AnalyticsSummary

    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 0) {
                StatGrid(summary: summary)
                    .padding(.vertical, 20)

                Divider()
                MetricSection(
                    title: "Total registered",
                    value: summary.registered.formatted(),
                    caption: "Cumulative registrations"
                ) {
                    RegisteredChart(points: summary.points)
                }

                Divider()
                MetricSection(
                    title: "Signups",
                    value: summary.signupsWindow.formatted(),
                    caption: "Last \(summary.points.count) days"
                ) {
                    SignupsChart(points: summary.points)
                }

                if let revenueDollars = summary.revenueDollars {
                    Divider()
                    MetricSection(
                        title: "Revenue",
                        value: dollars(revenueDollars),
                        caption: "Paid charges, last \(summary.revenue.count) days"
                    ) {
                        RevenueChart(points: summary.revenue)
                    }
                }

                Divider()
                MetricSection(
                    title: "Active users",
                    value: summary.active7d.map { $0.formatted() } ?? "—",
                    caption: activeCaption,
                    deltaPercent: summary.weekDeltaPercent
                ) {
                    ActiveChart(points: summary.points)
                }

                Divider()
                PeopleSection(analytics: analytics)

                if let generatedAt = summary.generatedAt {
                    Text(verbatim: "From the nightly rollup generated \(generatedAt.formatted(date: .abbreviated, time: .shortened)).")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                        .padding(.vertical, 16)
                }
            }
            .padding(.horizontal, 20)
        }
    }

    private var activeCaption: String {
        let base = "Active in the last 7 days"
        guard summary.missingDayCount > 0 else { return base }
        return "\(base) · \(summary.missingDayCount) days without data"
    }
}

// MARK: - Stats

private struct StatGrid: View {
    let summary: AnalyticsSummary

    var body: some View {
        LazyVGrid(columns: [GridItem(.flexible(), alignment: .topLeading), GridItem(.flexible(), alignment: .topLeading)], spacing: 20) {
            StatTile(
                label: "Registered users",
                value: summary.registered.formatted(),
                sub: "+\(summary.signups7d.formatted()) last 7 days"
            )
            StatTile(
                label: "Active yesterday",
                value: summary.activeYesterday.map { $0.formatted() } ?? "—",
                sub: summary.activeYesterday == nil ? "no extract yet" : "of \(summary.registered.formatted()) registered"
            )
            StatTile(
                label: "Pro subscribers",
                value: summary.subscribers.map { $0.formatted() } ?? "—",
                sub: summary.canceling.map { "\($0.formatted()) canceling" } ?? "not in this rollup"
            )
            StatTile(
                label: "Paid all time",
                value: summary.fundedDollars.map(dollars) ?? "—",
                sub: summary.funded.map { "by \($0.formatted()) people" } ?? "not in this rollup"
            )
        }
    }
}

/// The accounts the API ranks, a page at a time. The rows arrive as the list
/// reaches them: the last row asks for the next page, the same cursor the web
/// grid follows.
private struct PeopleSection: View {
    var analytics: AnalyticsModel

    var body: some View {
        VStack(alignment: .leading, spacing: 3) {
            HStack(alignment: .firstTextBaseline) {
                Text(verbatim: "People")
                    .font(.headline)
                Spacer()
                if !analytics.sorts.isEmpty {
                    Menu {
                        ForEach(analytics.sorts) { sort in
                            Button(sort.label) {
                                Task { await analytics.choosePeople(sort: sort.id) }
                            }
                        }
                    } label: {
                        Text(selectedLabel)
                            .font(.footnote.weight(.medium))
                    }
                }
            }
            Text(caption)
                .font(.footnote)
                .foregroundStyle(.secondary)

            LazyVStack(alignment: .leading, spacing: 0) {
                ForEach(analytics.people) { person in
                    PersonRow(person: person)
                        .task {
                            if person.id == analytics.people.last?.id {
                                await analytics.loadMorePeople()
                            }
                        }
                }
                if let peopleError = analytics.peopleError {
                    Text(peopleError)
                        .font(.footnote)
                        .foregroundStyle(.secondary)
                        .padding(.vertical, 12)
                } else if analytics.isLoadingPeople {
                    ProgressView()
                        .frame(maxWidth: .infinity)
                        .padding(.vertical, 12)
                }
            }
            .padding(.top, 8)
        }
        .padding(.vertical, 20)
        // The refresh that drew the charts is already fetching the first page;
        // this asks only when the section came up to an empty list.
        .task { if analytics.people.isEmpty { await analytics.loadMorePeople() } }
    }

    private var selectedLabel: String {
        analytics.sorts.first { $0.id == analytics.sort }?.label ?? "Sort"
    }

    private var caption: String {
        guard analytics.peopleTotal > 0 else { return "Accounts in rank order" }
        return "\(analytics.people.count.formatted()) of \(analytics.peopleTotal.formatted()) accounts"
    }
}

private struct PersonRow: View {
    let person: AnalyticsUsersPage.Person

    var body: some View {
        VStack(alignment: .leading, spacing: 2) {
            HStack(spacing: 6) {
                Text(person.email)
                    .font(.subheadline)
                    .lineLimit(1)
                if person.superUser == true {
                    Text(verbatim: "su")
                        .font(.caption2)
                        .foregroundStyle(.secondary)
                        .padding(.horizontal, 4)
                        .padding(.vertical, 1)
                        .background(Color.secondary.opacity(0.15), in: RoundedRectangle(cornerRadius: 4))
                }
            }
            Text(sub)
                .font(.caption)
                .foregroundStyle(.secondary)
                .lineLimit(1)
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .padding(.vertical, 8)
    }

    private var sub: String {
        var parts = [
            person.activeDays == 0
                ? "no activity"
                : "\(person.activeDays) active \(person.activeDays == 1 ? "day" : "days")",
            "joined \(joined)",
            usd(person.balanceMicros),
        ]
        if let funded = person.fundedMicros {
            parts.append("paid \(usd(funded))")
        }
        return parts.joined(separator: " · ")
    }

    private func usd(_ micros: String) -> String {
        dollars((Double(micros) ?? 0) / 1_000_000)
    }

    private var joined: String {
        let iso = ISO8601DateFormatter()
        iso.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        let date = iso.date(from: person.registeredAt) ?? ISO8601DateFormatter().date(from: person.registeredAt)
        return date?.formatted(.dateTime.month(.abbreviated).day()) ?? String(person.registeredAt.prefix(10))
    }
}

private struct StatTile: View {
    let label: String
    let value: String
    let sub: String

    var body: some View {
        VStack(alignment: .leading, spacing: 2) {
            Text(label)
                .font(.footnote)
                .foregroundStyle(.secondary)
            Text(value)
                .font(.title2.weight(.semibold))
                .monospacedDigit()
            Text(sub)
                .font(.caption)
                .foregroundStyle(.secondary)
        }
        .frame(maxWidth: .infinity, alignment: .leading)
    }
}

// MARK: - Sections

private struct MetricSection<ChartContent: View>: View {
    let title: String
    let value: String
    let caption: String
    var deltaPercent: Double?
    @ViewBuilder let chart: () -> ChartContent

    var body: some View {
        VStack(alignment: .leading, spacing: 3) {
            HStack(alignment: .firstTextBaseline) {
                Text(title)
                    .font(.headline)
                Spacer()
                if let deltaPercent {
                    DeltaBadge(percent: deltaPercent)
                }
            }
            Text(value)
                .font(.title.weight(.semibold))
                .monospacedDigit()
            Text(caption)
                .font(.footnote)
                .foregroundStyle(.secondary)
            chart()
                .frame(height: 200)
                .padding(.top, 16)
        }
        .padding(.vertical, 20)
    }
}

private struct DeltaBadge: View {
    let percent: Double

    var body: some View {
        Text(verbatim: "\(percent >= 0 ? "+" : "")\(percent.formatted(.number.precision(.fractionLength(1))))%")
            .font(.footnote.weight(.semibold))
            .monospacedDigit()
            .foregroundStyle(percent < 0 ? .red : .green)
            .padding(.horizontal, 8)
            .padding(.vertical, 3)
            .background((percent < 0 ? Color.red : Color.green).opacity(0.12), in: Capsule())
    }
}

// MARK: - Charts

private let workingPurple = Color(hex: "#9d7bff")

private struct ActiveChart: View {
    let points: [AnalyticsSummary.DayPoint]

    var body: some View {
        Chart {
            ForEach(points.filter { $0.active != nil }) { point in
                LineMark(
                    x: .value("Day", point.day, unit: .day),
                    y: .value("Users", point.active ?? 0)
                )
                .foregroundStyle(by: .value("Series", "Active"))
                .interpolationMethod(.monotone)
            }
            ForEach(points.filter { $0.working != nil }) { point in
                LineMark(
                    x: .value("Day", point.day, unit: .day),
                    y: .value("Users", point.working ?? 0)
                )
                .foregroundStyle(by: .value("Series", "Working"))
                .interpolationMethod(.monotone)
            }
        }
        .chartForegroundStyleScale(["Active": Color.accentBlue, "Working": workingPurple])
        .chartLegend(position: .bottom, spacing: 12)
        .analyticsAxes()
    }
}

private struct SignupsChart: View {
    let points: [AnalyticsSummary.DayPoint]

    var body: some View {
        Chart(points) { point in
            BarMark(
                x: .value("Day", point.day, unit: .day),
                y: .value("Signups", point.signups)
            )
            .foregroundStyle(Color.accentBlue)
        }
        .analyticsAxes()
    }
}

private struct RevenueChart: View {
    let points: [AnalyticsSummary.RevenuePoint]

    var body: some View {
        Chart {
            ForEach(points) { point in
                BarMark(
                    x: .value("Day", point.day, unit: .day),
                    y: .value("Dollars", point.proDollars)
                )
                .foregroundStyle(by: .value("Series", "Pro"))
                BarMark(
                    x: .value("Day", point.day, unit: .day),
                    y: .value("Dollars", point.topupDollars)
                )
                .foregroundStyle(by: .value("Series", "Top-ups"))
            }
        }
        .chartForegroundStyleScale(["Pro": Color.accentBlue, "Top-ups": workingPurple])
        .chartLegend(position: .bottom, spacing: 12)
        .analyticsAxes()
    }
}

private struct RegisteredChart: View {
    let points: [AnalyticsSummary.DayPoint]

    var body: some View {
        Chart(points) { point in
            LineMark(
                x: .value("Day", point.day, unit: .day),
                y: .value("Users", point.totalRegistered)
            )
            .foregroundStyle(Color.accentBlue)
            .interpolationMethod(.monotone)
        }
        .chartYScale(domain: .automatic(includesZero: false))
        .analyticsAxes()
    }
}

extension View {
    fileprivate func analyticsAxes() -> some View {
        chartXAxis {
            AxisMarks(values: .automatic(desiredCount: 4)) {
                AxisGridLine()
                AxisValueLabel(format: .dateTime.month(.abbreviated).day(), centered: false)
            }
        }
    }
}

private func dollars(_ value: Double) -> String {
    value.formatted(.currency(code: "USD").precision(.fractionLength(value == value.rounded() ? 0 : 2)))
}
#endif