import Foundation
import AlignerCore

struct Round015EntitlementLaunchOptions {
    let fixtureState: EntitlementFixtureState?
    let now: Date?
    let trialStartedAt: Date?
    let lastSuccessfulVerifyAt: Date?
    let verifyResult: VerifyResult?
    let usesEphemeralLicenseStore: Bool
    let debugLicenseKey: DebugLicenseKey?

    enum VerifyResult: String {
        case success
        case networkFailure
        case invalid
        case revoked
        case serverError
        case timeout
    }

    enum DebugLicenseKey: String {
        case valid
        case invalid
        case revoked
    }

    static func parse(arguments: [String]) -> Round015EntitlementLaunchOptions {
        Round015EntitlementLaunchOptions(
            fixtureState: stringValue(for: "--round015-license-state", in: arguments)
                .flatMap(EntitlementFixtureState.init(rawValue:)),
            now: dateValue(for: "--round015-now", in: arguments),
            trialStartedAt: dateValue(for: "--round015-trial-started-at", in: arguments),
            lastSuccessfulVerifyAt: dateValue(for: "--round015-last-successful-verify-at", in: arguments),
            verifyResult: stringValue(for: "--round015-verify-result", in: arguments)
                .flatMap(VerifyResult.init(rawValue:)),
            usesEphemeralLicenseStore: arguments.contains("--round015-ephemeral-license-store"),
            debugLicenseKey: stringValue(for: "--round015-debug-license-key", in: arguments)
                .flatMap(DebugLicenseKey.init(rawValue:))
        )
    }

    func authorizationReportDictionary() -> [String: Any] {
        guard let snapshot else {
            return [
                "state": "notConfigured",
                "proFeature": ProFeature.windowShortcutActivation.rawValue,
                "proFeatureUnlocked": false,
                "fixtureEnabled": false,
                "ephemeralLicenseStore": usesEphemeralLicenseStore,
                "licenseKeyPresent": debugLicenseKey != nil,
                "licenseKeyFingerprint": debugLicenseKey.map { DevelopmentDiagnostics.stableFingerprint($0.rawValue) } ?? NSNull()
            ]
        }

        let evaluationNow = effectiveNow
        let entitlement = EntitlementPolicy.evaluate(
            snapshot: snapshot,
            feature: .windowShortcutActivation,
            now: evaluationNow
        )

        var report: [String: Any] = [
            "state": stateLabel(entitlement),
            "proFeature": ProFeature.windowShortcutActivation.rawValue,
            "proFeatureUnlocked": entitlement.isProAllowed,
            "decision": decisionLabel(entitlement),
            "decisionReason": decisionReasonLabel(entitlement),
            "fixtureEnabled": fixtureState != nil,
            "fixtureState": fixtureState?.rawValue ?? NSNull(),
            "ephemeralLicenseStore": usesEphemeralLicenseStore,
            "now": Self.string(from: evaluationNow),
            "trialStartedAt": trialStartedAtString(from: snapshot.trialState) ?? NSNull(),
            "trialEndsAt": trialEndsAtString(from: snapshot.trialState) ?? NSNull(),
            "trialDaysRemaining": trialDaysRemaining(from: snapshot.trialState, now: evaluationNow) ?? NSNull(),
            "lastVerifyResult": lastVerifyResultLabel(from: snapshot.validationFreshness),
            "lastSuccessfulVerifyAt": lastSuccessfulVerifyAtString(from: snapshot.validationFreshness) ?? NSNull(),
            "offlineGraceEndsAt": offlineGraceEndsAtString(from: snapshot.validationFreshness) ?? NSNull(),
            "offlineGraceRemainingDays": offlineGraceRemainingDays(from: snapshot.validationFreshness, now: evaluationNow) ?? NSNull(),
            "licenseKeyPresent": debugLicenseKey != nil || licenseKeyPresent(in: snapshot.licenseState),
            "licenseKeyFingerprint": licenseFingerprint(from: snapshot.licenseState)
                ?? debugLicenseKey.map { DevelopmentDiagnostics.stableFingerprint($0.rawValue) }
                ?? NSNull()
        ]

        if let verifyResult {
            report["fixtureVerifyResult"] = verifyResult.rawValue
        }
        if let debugLicenseKey {
            report["debugLicenseKeyKind"] = debugLicenseKey.rawValue
        }

        return report
    }

    private var effectiveNow: Date {
        now ?? Date()
    }

    private var snapshot: EntitlementSnapshot? {
        guard fixtureState != nil
                || trialStartedAt != nil
                || lastSuccessfulVerifyAt != nil
                || verifyResult != nil
                || debugLicenseKey != nil
        else {
            return nil
        }

        if fixtureState == nil {
            return snapshotFromOverrides(base: EntitlementFixtureState.trialExpired)
        }

        return snapshotFromOverrides(base: fixtureState ?? .trialExpired)
    }

    private func snapshotFromOverrides(base fixtureState: EntitlementFixtureState) -> EntitlementSnapshot {
        var snapshot = FixtureEntitlementProvider(
            fixtureState: fixtureState,
            now: effectiveNow
        ).snapshot

        if let trialStartedAt {
            snapshot.trialState = trialState(
                from: snapshot.trialState,
                startedAt: trialStartedAt,
                now: effectiveNow
            )
        }

        if let debugLicenseKey {
            snapshot.licenseState = licenseState(for: debugLicenseKey)
        }

        if let verifyResult {
            snapshot.validationFreshness = validationFreshness(
                for: verifyResult,
                now: effectiveNow,
                lastSuccessfulVerifyAt: lastSuccessfulVerifyAt
            )
        } else if let lastSuccessfulVerifyAt {
            snapshot.validationFreshness = .valid(
                lastValidAt: lastSuccessfulVerifyAt,
                nextCheckAt: lastSuccessfulVerifyAt.addingTimeInterval(24 * 60 * 60)
            )
        }

        return snapshot
    }

    private func trialState(from base: TrialState, startedAt: Date, now: Date) -> TrialState {
        let expiresAt = startedAt.addingTimeInterval(EntitlementPolicy.defaultTrialDuration)
        switch base {
        case .expired:
            return now < expiresAt
                ? .active(startedAt: startedAt, expiresAt: expiresAt)
                : .expired(startedAt: startedAt, expiredAt: expiresAt)
        default:
            return .active(startedAt: startedAt, expiresAt: expiresAt)
        }
    }

    private func licenseState(for debugLicenseKey: DebugLicenseKey) -> LicenseState {
        switch debugLicenseKey {
        case .valid:
            return .activated(
                fingerprint: DevelopmentDiagnostics.stableFingerprint("round015-valid"),
                instanceID: "round015-fixture-instance",
                status: .active
            )
        case .invalid:
            return .revokedOrExpiredRemote(reason: .invalid)
        case .revoked:
            return .revokedOrExpiredRemote(reason: .revoked)
        }
    }

    private func validationFreshness(
        for verifyResult: VerifyResult,
        now: Date,
        lastSuccessfulVerifyAt: Date?
    ) -> ValidationFreshness {
        switch verifyResult {
        case .success:
            let lastValidAt = lastSuccessfulVerifyAt ?? now
            return .valid(
                lastValidAt: lastValidAt,
                nextCheckAt: lastValidAt.addingTimeInterval(24 * 60 * 60)
            )
        case .networkFailure, .serverError, .timeout:
            return EntitlementPolicy.offlineGrace(lastAttemptAt: now)
        case .invalid:
            return .hardFailure(reason: .invalid)
        case .revoked:
            return .hardFailure(reason: .revoked)
        }
    }

    private func stateLabel(_ entitlement: EffectiveEntitlement) -> String {
        switch entitlement {
        case let .proAllowed(reason):
            return reason.rawValue
        case let .proDenied(reason):
            return reason.rawValue
        }
    }

    private func decisionLabel(_ entitlement: EffectiveEntitlement) -> String {
        entitlement.isProAllowed ? "allowed" : "blocked"
    }

    private func decisionReasonLabel(_ entitlement: EffectiveEntitlement) -> String {
        switch entitlement {
        case let .proAllowed(reason):
            return reason.rawValue
        case let .proDenied(reason):
            return reason.rawValue
        }
    }

    private func trialStartedAtString(from state: TrialState) -> String? {
        switch state {
        case let .active(startedAt, _), let .expired(startedAt, _):
            return Self.string(from: startedAt)
        case .notInitialized, .invalidLocalRecord:
            return nil
        }
    }

    private func trialEndsAtString(from state: TrialState) -> String? {
        switch state {
        case let .active(_, expiresAt), let .expired(_, expiresAt):
            return Self.string(from: expiresAt)
        case .notInitialized, .invalidLocalRecord:
            return nil
        }
    }

    private func trialDaysRemaining(from state: TrialState, now: Date) -> Int? {
        guard case let .active(_, expiresAt) = state else { return nil }
        return max(0, Int(ceil(expiresAt.timeIntervalSince(now) / (24 * 60 * 60))))
    }

    private func lastVerifyResultLabel(from freshness: ValidationFreshness) -> String {
        switch freshness {
        case .neverChecked:
            return "neverChecked"
        case .valid:
            return "success"
        case .temporaryFailure:
            return "temporaryFailure"
        case let .hardFailure(reason):
            return reason.rawValue
        }
    }

    private func lastSuccessfulVerifyAtString(from freshness: ValidationFreshness) -> String? {
        switch freshness {
        case let .valid(lastValidAt, _):
            return Self.string(from: lastValidAt)
        case .neverChecked, .temporaryFailure, .hardFailure:
            return nil
        }
    }

    private func offlineGraceEndsAtString(from freshness: ValidationFreshness) -> String? {
        switch freshness {
        case let .temporaryFailure(_, graceUntil):
            return Self.string(from: graceUntil)
        case .neverChecked, .valid, .hardFailure:
            return nil
        }
    }

    private func offlineGraceRemainingDays(from freshness: ValidationFreshness, now: Date) -> Int? {
        guard case let .temporaryFailure(_, graceUntil) = freshness else { return nil }
        return max(0, Int(ceil(graceUntil.timeIntervalSince(now) / (24 * 60 * 60))))
    }

    private func licenseKeyPresent(in state: LicenseState) -> Bool {
        switch state {
        case .activated:
            return true
        case .none, .deactivatedLocal, .revokedOrExpiredRemote, .mismatch:
            return false
        }
    }

    private func licenseFingerprint(from state: LicenseState) -> String? {
        switch state {
        case let .activated(fingerprint, _, _):
            return fingerprint
        case .none, .deactivatedLocal, .revokedOrExpiredRemote, .mismatch:
            return nil
        }
    }

    private static func dateValue(for key: String, in arguments: [String]) -> Date? {
        guard let value = stringValue(for: key, in: arguments) else { return nil }

        return iso8601Date(from: value, fractionalSeconds: true)
            ?? iso8601Date(from: value, fractionalSeconds: false)
    }

    private static func stringValue(for key: String, in arguments: [String]) -> String? {
        let prefix = "\(key)="
        guard let argument = arguments.first(where: { $0.hasPrefix(prefix) }) else {
            return nil
        }

        return String(argument.dropFirst(prefix.count))
    }

    private static func string(from date: Date) -> String {
        let formatter = ISO8601DateFormatter()
        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        return formatter.string(from: date)
    }

    private static func iso8601Date(from value: String, fractionalSeconds: Bool) -> Date? {
        let formatter = ISO8601DateFormatter()
        formatter.formatOptions = fractionalSeconds
            ? [.withInternetDateTime, .withFractionalSeconds]
            : [.withInternetDateTime]
        return formatter.date(from: value)
    }
}