path: root/DomainDigCLI.swift

import Foundation

@main
struct DomainDigCLI {
    static func main() async {
        let arguments = Array(CommandLine.arguments.dropFirst())
        let wantsJSON = arguments.contains("--json") || arguments.contains("-j")

        guard let command = CommandLine.arguments.first else {
            fputs(usageText, stderr)
            Foundation.exit(1)
        }
        _ = command

        if arguments.first == "backup" {
            runBackupCommand(arguments: Array(arguments.dropFirst()), wantsJSON: wantsJSON)
            return
        }

        if arguments.first == "monitor" {
            await runMonitorCommand(wantsJSON: wantsJSON)
            return
        }

        let wantsOwnershipHistory = arguments.contains("--ownership-history")
        let wantsDNSHistory = arguments.contains("--dns-history")
        let wantsExtendedSubdomains = arguments.contains("--extended-subdomains")
        let wantsPricing = arguments.contains("--pricing")
        let wantsUsage = arguments.contains("--show-usage")
        let domains = arguments.filter { !$0.hasPrefix("-") }

        let requestedDomains = domains
            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
            .filter { !$0.isEmpty }

        guard !requestedDomains.isEmpty else {
            fputs(usageText, stderr)
            Foundation.exit(1)
        }

        let inspectionService = DomainInspectionService()
        let reportBuilder = DomainReportBuilder()
        var reports: [DomainReport] = []
        var seen = Set<String>()
        var usageImpact: [String] = []

        for domain in requestedDomains {
            let normalizedDomain = domain.lowercased()
            guard seen.insert(normalizedDomain).inserted else { continue }
            let snapshot = await inspectionService.inspectSnapshot(domain: domain)
            let enrichedSnapshot = await enrichSnapshot(
                snapshot,
                wantsOwnershipHistory: wantsOwnershipHistory,
                wantsDNSHistory: wantsDNSHistory,
                wantsExtendedSubdomains: wantsExtendedSubdomains,
                wantsPricing: wantsPricing,
                usageImpact: &usageImpact
            )
            reports.append(reportBuilder.build(from: enrichedSnapshot))
        }

        do {
            let data: Data
            if reports.count == 1, let report = reports.first {
                data = try DomainReportExporter.data(
                    for: report,
                    format: wantsJSON ? .json : .text
                )
            } else {
                data = try DomainReportExporter.data(
                    for: reports,
                    format: wantsJSON ? .json : .text,
                    title: "DomainDig Batch Report"
                )
            }
            if wantsUsage, !usageImpact.isEmpty {
                FileHandle.standardError.write(Data(("Data+ usage impact: " + usageImpact.joined(separator: ", ") + "\n").utf8))
            }
            FileHandle.standardOutput.write(data)
            if data.last != 0x0A {
                FileHandle.standardOutput.write(Data([0x0A]))
            }
        } catch {
            fputs("domaindig: \(error.localizedDescription)\n", stderr)
            Foundation.exit(1)
        }
    }

    private static func enrichSnapshot(
        _ snapshot: LookupSnapshot,
        wantsOwnershipHistory: Bool,
        wantsDNSHistory: Bool,
        wantsExtendedSubdomains: Bool,
        wantsPricing: Bool,
        usageImpact: inout [String]
    ) async -> LookupSnapshot {
        guard FeatureAccessService.currentTier == .dataPlus else {
            return snapshot
        }

        let historyEntries = loadHistoryEntries()
        var ownershipHistory = snapshot.ownershipHistory
        var ownershipHistoryError = snapshot.ownershipHistoryError
        var dnsHistory = snapshot.dnsHistory
        var dnsHistoryError = snapshot.dnsHistoryError
        var extendedSubdomains = snapshot.extendedSubdomains
        var extendedSubdomainsError = snapshot.extendedSubdomainsError
        var domainPricing = snapshot.domainPricing
        var domainPricingError = snapshot.domainPricingError

        if wantsOwnershipHistory,
           await UsageCreditService.shared.canUse(.ownershipHistory) {
            let outcome = await ExternalDataService.shared.ownershipHistory(
                domain: snapshot.domain,
                currentOwnership: snapshot.ownership,
                historyEntries: historyEntries
            )
            switch outcome.value {
            case let .success(events):
                ownershipHistory = events
                ownershipHistoryError = nil
                if outcome.source != .cached {
                    _ = await UsageCreditService.shared.consume(.ownershipHistory)
                    usageImpact.append("ownership history -1")
                }
            case let .empty(message):
                ownershipHistoryError = message
                if outcome.source != .cached {
                    _ = await UsageCreditService.shared.consume(.ownershipHistory)
                    usageImpact.append("ownership history -1")
                }
            case let .error(message):
                ownershipHistoryError = message
            }
        }

        if wantsDNSHistory,
           await UsageCreditService.shared.canUse(.dnsHistory) {
            let outcome = await ExternalDataService.shared.dnsHistory(
                domain: snapshot.domain,
                dnsSections: snapshot.dnsSections,
                historyEntries: historyEntries
            )
            switch outcome.value {
            case let .success(events):
                dnsHistory = events
                dnsHistoryError = nil
                if outcome.source != .cached {
                    _ = await UsageCreditService.shared.consume(.dnsHistory)
                    usageImpact.append("dns history -1")
                }
            case let .empty(message):
                dnsHistoryError = message
                if outcome.source != .cached {
                    _ = await UsageCreditService.shared.consume(.dnsHistory)
                    usageImpact.append("dns history -1")
                }
            case let .error(message):
                dnsHistoryError = message
            }
        }

        if wantsExtendedSubdomains,
           await UsageCreditService.shared.canUse(.extendedSubdomains) {
            let outcome = await ExternalDataService.shared.extendedSubdomains(
                domain: snapshot.domain,
                existing: snapshot.subdomains
            )
            switch outcome.value {
            case let .success(results):
                extendedSubdomains = results
                extendedSubdomainsError = nil
                if outcome.source != .cached {
                    _ = await UsageCreditService.shared.consume(.extendedSubdomains)
                    usageImpact.append("extended subdomains -1")
                }
            case let .empty(message):
                extendedSubdomainsError = message
                if outcome.source != .cached {
                    _ = await UsageCreditService.shared.consume(.extendedSubdomains)
                    usageImpact.append("extended subdomains -1")
                }
            case let .error(message):
                extendedSubdomainsError = message
            }
        }

        if wantsPricing {
            let outcome = await ExternalDataService.shared.pricing(domain: snapshot.domain)
            switch outcome.value {
            case let .success(pricing):
                domainPricing = pricing
                domainPricingError = nil
            case let .empty(message), let .error(message):
                domainPricingError = message
            }
        }

        return LookupSnapshot(
            historyEntryID: snapshot.historyEntryID,
            domain: snapshot.domain,
            timestamp: snapshot.timestamp,
            trackedDomainID: snapshot.trackedDomainID,
            note: snapshot.note,
            appVersion: snapshot.appVersion,
            resolverDisplayName: snapshot.resolverDisplayName,
            resolverURLString: snapshot.resolverURLString,
            dataSources: snapshot.dataSources,
            provenanceBySection: snapshot.provenanceBySection,
            availabilityConfidence: snapshot.availabilityConfidence,
            ownershipConfidence: snapshot.ownershipConfidence,
            subdomainConfidence: snapshot.subdomainConfidence,
            emailSecurityConfidence: snapshot.emailSecurityConfidence,
            geolocationConfidence: snapshot.geolocationConfidence,
            errorDetails: snapshot.errorDetails,
            isPartialSnapshot: snapshot.isPartialSnapshot,
            validationIssues: snapshot.validationIssues,
            totalLookupDurationMs: snapshot.totalLookupDurationMs,
            dnsSections: snapshot.dnsSections,
            dnsError: snapshot.dnsError,
            availabilityResult: snapshot.availabilityResult,
            suggestions: snapshot.suggestions,
            sslInfo: snapshot.sslInfo,
            sslError: snapshot.sslError,
            hstsPreloaded: snapshot.hstsPreloaded,
            httpHeaders: snapshot.httpHeaders,
            httpSecurityGrade: snapshot.httpSecurityGrade,
            httpStatusCode: snapshot.httpStatusCode,
            httpResponseTimeMs: snapshot.httpResponseTimeMs,
            httpProtocol: snapshot.httpProtocol,
            http3Advertised: snapshot.http3Advertised,
            httpHeadersError: snapshot.httpHeadersError,
            reachabilityResults: snapshot.reachabilityResults,
            reachabilityError: snapshot.reachabilityError,
            ipGeolocation: snapshot.ipGeolocation,
            ipGeolocationError: snapshot.ipGeolocationError,
            emailSecurity: snapshot.emailSecurity,
            emailSecurityError: snapshot.emailSecurityError,
            ownership: snapshot.ownership,
            ownershipError: snapshot.ownershipError,
            ownershipHistory: ownershipHistory,
            ownershipHistoryError: ownershipHistoryError,
            ptrRecord: snapshot.ptrRecord,
            ptrError: snapshot.ptrError,
            redirectChain: snapshot.redirectChain,
            redirectChainError: snapshot.redirectChainError,
            subdomains: snapshot.subdomains,
            subdomainsError: snapshot.subdomainsError,
            extendedSubdomains: extendedSubdomains,
            extendedSubdomainsError: extendedSubdomainsError,
            dnsHistory: dnsHistory,
            dnsHistoryError: dnsHistoryError,
            domainPricing: domainPricing,
            domainPricingError: domainPricingError,
            portScanResults: snapshot.portScanResults,
            portScanError: snapshot.portScanError,
            changeSummary: snapshot.changeSummary,
            resultSource: snapshot.resultSource,
            cachedSections: snapshot.cachedSections,
            statusMessage: snapshot.statusMessage
        )
    }

    private static func loadHistoryEntries() -> [HistoryEntry] {
        DomainDataPortabilityService.loadHistoryEntries()
    }

    private static func runBackupCommand(arguments: [String], wantsJSON: Bool) {
        guard let subcommand = arguments.first else {
            fputs(usageText, stderr)
            Foundation.exit(1)
        }

        switch subcommand {
        case "export":
            do {
                let data = try DomainDataPortabilityService.backupData()
                let outputPath = arguments.dropFirst().first(where: { !$0.hasPrefix("-") })
                if let outputPath {
                    try data.write(to: URL(fileURLWithPath: outputPath), options: .atomic)
                } else {
                    FileHandle.standardOutput.write(data)
                    if data.last != 0x0A {
                        FileHandle.standardOutput.write(Data([0x0A]))
                    }
                }
            } catch {
                fputs("domaindig backup export: \(error.localizedDescription)\n", stderr)
                Foundation.exit(1)
            }
        case "validate":
            guard let path = arguments.dropFirst().first(where: { !$0.hasPrefix("-") }) else {
                fputs("usage: domaindig backup validate <path>\n", stderr)
                Foundation.exit(1)
            }

            do {
                let data = try Data(contentsOf: URL(fileURLWithPath: path))
                let report = try DomainDataPortabilityService.validateBackup(data: data, fileName: URL(fileURLWithPath: path).lastPathComponent)
                if wantsJSON {
                    let payload = [
                        "warnings": report.warnings,
                        "errors": report.errors
                    ]
                    let encoded = try JSONSerialization.data(withJSONObject: payload, options: [.prettyPrinted, .sortedKeys])
                    FileHandle.standardOutput.write(encoded)
                } else {
                    let lines = [
                        "Warnings: \(report.warnings.count)",
                        "Errors: \(report.errors.count)"
                    ] + report.warnings.map { "warning: \($0)" } + report.errors.map { "error: \($0)" }
                    FileHandle.standardOutput.write(Data(lines.joined(separator: "\n").utf8))
                }
                FileHandle.standardOutput.write(Data([0x0A]))
                if !report.errors.isEmpty {
                    Foundation.exit(1)
                }
            } catch {
                fputs("domaindig backup validate: \(error.localizedDescription)\n", stderr)
                Foundation.exit(1)
            }
        case "import":
            guard let path = arguments.dropFirst().first(where: { !$0.hasPrefix("-") }) else {
                fputs("usage: domaindig backup import <path> [--replace]\n", stderr)
                Foundation.exit(1)
            }

            let mode: DataPortabilityImportMode = arguments.contains("--replace") ? .replace : .merge

            do {
                let fileURL = URL(fileURLWithPath: path)
                let data = try Data(contentsOf: fileURL)
                let preview = try DomainDataPortabilityService.prepareImport(
                    data: data,
                    fileName: fileURL.lastPathComponent,
                    mode: mode
                )
                guard preview.kind == .backup else {
                    fputs("domaindig backup import: expected a full backup file\n", stderr)
                    Foundation.exit(1)
                }
                let result = try DomainDataPortabilityService.applyImport(preview, mode: mode)
                let lines = [result.summary] + result.warnings.map { "warning: \($0)" }
                FileHandle.standardOutput.write(Data(lines.joined(separator: "\n").utf8))
                FileHandle.standardOutput.write(Data([0x0A]))
            } catch {
                fputs("domaindig backup import: \(error.localizedDescription)\n", stderr)
                Foundation.exit(1)
            }
        default:
            fputs(usageText, stderr)
            Foundation.exit(1)
        }
    }

    private static func runMonitorCommand(wantsJSON: Bool) async {
        guard FeatureAccessService.hasAccess(to: .automatedMonitoring) else {
            fputs("domaindig monitor: monitoring requires Pro\n", stderr)
            Foundation.exit(1)
        }

        let outcome = await DomainMonitoringService.shared.performMonitoring(
            trigger: .cli,
            requireEnabledSetting: false
        )

        guard let log = outcome.log else {
            fputs("domaindig monitor: \(outcome.message)\n", stderr)
            Foundation.exit(1)
        }

        do {
            let output: Data
            if wantsJSON {
                let encoder = JSONEncoder()
                encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
                output = try encoder.encode(log)
            } else {
                output = Data(monitoringTextSummary(for: log).utf8)
            }
            FileHandle.standardOutput.write(output)
            if output.last != 0x0A {
                FileHandle.standardOutput.write(Data([0x0A]))
            }
            if !outcome.success {
                Foundation.exit(1)
            }
        } catch {
            fputs("domaindig monitor: \(error.localizedDescription)\n", stderr)
            Foundation.exit(1)
        }
    }

    private static func monitoringTextSummary(for log: MonitoringLog) -> String {
        var lines = [
            "DomainDig Monitoring",
            "====================",
            "Trigger: \(log.trigger.title)",
            "Timestamp: \(log.timestamp.formatted(date: .abbreviated, time: .shortened))",
            "Checked: \(log.domainsChecked)",
            "Changes: \(log.changesFound)",
            "Alerts: \(log.alertsTriggered)",
            ""
        ]

        if log.checkedDomains.isEmpty {
            lines.append("No domains were checked.")
        } else {
            for result in log.checkedDomains {
                let severity = result.alertSeverity?.title ?? "None"
                lines.append("\(result.domain): \(result.summaryMessage) [alert: \(severity)]")
            }
        }

        if !log.errors.isEmpty {
            lines.append("")
            lines.append("Errors:")
            lines.append(contentsOf: log.errors.map { "- \($0)" })
        }

        return lines.joined(separator: "\n")
    }

    private static var usageText: String {
        """
        usage: domaindig <domain> [--json] [--ownership-history] [--dns-history] [--extended-subdomains] [--pricing] [--show-usage]
               domaindig monitor [--json]
               domaindig backup export [path]
               domaindig backup import <path> [--replace]
               domaindig backup validate <path> [--json]
        """
    }
}