// study-67-pwa-spectral-conflict-court.swift
// Swift 6.4 — Zero-Import, Zero-Float Unified Piecewise-Affine (PWA), Spectral Fiedler Cut ILP,
// Online Scammer Tarpit, Active Kinetic Horizon Guard & Public-Safety De-Escalation Court
//
// Unifies four isomorphic integer-lattice control domains on M_8 = S^4 x C^4 subset Z^8:
//   PILLAR I:   Multi-Domain PWA Salvo & Spectral Graph Laplacian (L_B, Fiedler lambda_2, kappa_crit = 854/1024)
//   PILLAR II:  Exact Spectral Target Allocation (Courant-Fischer Fiedler Cut ILP phi_j = sum w_ij (v_{2,i} - v_{2,j})^2)
//   PILLAR III: Online Scammer Tarpit (+b_tarpit ROI exhaustion) & Active Kinetic Horizon-Lock Guard (45-deg shear)
//   PILLAR IV:  Public-Safety De-Escalation Language-Game Controller (H_kinetic = alpha_k - rho_k - iota_k/2)

@inline(__always)
public func binaryGCD(_ a: Int64, _ b: Int64) -> Int64 {
    var u = a < 0 ? -a : a
    var v = b < 0 ? -b : b
    if u == 0 { return v == 0 ? 1 : v }
    if v == 0 { return u }
    while v != 0 {
        let t = u % v
        u = v
        v = t
    }
    return u
}

@inline(__always)
public func hex16(_ v: UInt64) -> String {
    let digits: [Character] = ["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"]
    var out = ""
    out.reserveCapacity(16)
    for shift in stride(from: 60, through: 0, by: -4) {
        let nibble = Int((v >> UInt64(shift)) & 0xF)
        out.append(digits[nibble])
    }
    return out
}

public struct CombatLatticeState: Sendable, Equatable {
    public var aUnits: Int64
    public var bUnits: Int64
    public var aMagazine: Int64
    public var bMagazine: Int64
    public var aEnergy: Int64
    public var bEnergy: Int64
    public var aConnectivity: Int64
    public var bConnectivity: Int64
    public var tick: Int64
    public var cumulativeOverkillA: Int64
    public var cumulativeOverkillB: Int64
}

public struct AffineSalvoParameters: Sendable {
    public let domainName: String
    public let alpha: Int64
    public let beta: Int64
    public let yDefenseLocal: Int64
    public let zDefenseLocal: Int64
    public let wStay: Int64
    public let xStay: Int64
    public let decoyShiftA: Int64
    public let decoyShiftB: Int64
    public let subgraphsMA: Int64
    public let subgraphsMB: Int64
    public let targetFocusCA: Int64
    public let targetFocusCB: Int64
    public let metabolicBurnA: Int64
    public let metabolicBurnB: Int64
    public let transportLagTau: Int64
}

@inline(__always)
public func computeEffectiveDefensePool(
    activeNodesB: Int64,
    targetedNodesC: Int64,
    localDefenseZ: Int64,
    subgraphsM: Int64,
    kappaConnectivity: Int64
) -> Int64 {
    guard activeNodesB > 0 else { return 0 }
    let clusterSize = max(1, activeNodesB / max(1, subgraphsM))
    let clampedTarget = min(clusterSize, max(1, targetedNodesC))
    let supportingNodes = clusterSize - clampedTarget

    let scale: Int64 = 1024
    let clampedKappa = max(0, kappaConnectivity)
    let etaScaled = (scale * clampedKappa) / (scale + clampedKappa)

    let organicPool = clampedTarget * localDefenseZ
    let cooperativePool = (supportingNodes * localDefenseZ * etaScaled) / scale

    return organicPool + cooperativePool
}

public func computeCriticalKappaThreshold(
    incomingSalvoOnB: Int64,
    activeNodesB: Int64,
    targetedNodesC: Int64,
    localDefenseZ: Int64,
    subgraphsM: Int64,
    decoyShiftB: Int64
) -> Int64 {
    let requiredPool = incomingSalvoOnB - decoyShiftB
    let clusterSize = max(1, activeNodesB / max(1, subgraphsM))
    let clampedTarget = min(clusterSize, max(1, targetedNodesC))
    let organicPool = clampedTarget * localDefenseZ
    if requiredPool <= organicPool {
        return 0
    }
    let supportingNodes = clusterSize - clampedTarget
    let maxCoopPool = supportingNodes * localDefenseZ
    let neededCoop = requiredPool - organicPool
    if neededCoop >= maxCoopPool {
        return 1_048_576
    }
    let num = 1024 * neededCoop
    let den = maxCoopPool - neededCoop
    return (num + den - 1) / den
}

public func stepAffineSalvo(
    state: CombatLatticeState,
    params: AffineSalvoParameters
) -> CombatLatticeState {
    guard state.aUnits > 0 && state.bUnits > 0 else { return state }

    let aCanFire = state.aEnergy > 0 && state.aMagazine > 0
    let bCanFire = state.bEnergy > 0 && state.bMagazine > 0
    let effAlpha = aCanFire ? min(params.alpha, state.aMagazine) : 0
    let effBeta  = bCanFire ? min(params.beta,  state.bMagazine) : 0

    let zPoolB = computeEffectiveDefensePool(
        activeNodesB: state.bUnits,
        targetedNodesC: params.targetFocusCB,
        localDefenseZ: params.zDefenseLocal,
        subgraphsM: params.subgraphsMB,
        kappaConnectivity: state.bConnectivity
    )
    let yPoolA = computeEffectiveDefensePool(
        activeNodesB: state.aUnits,
        targetedNodesC: params.targetFocusCA,
        localDefenseZ: params.yDefenseLocal,
        subgraphsM: params.subgraphsMA,
        kappaConnectivity: state.aConnectivity
    )

    let rawLeakersOnB = (effAlpha * state.aUnits) - zPoolB - params.decoyShiftB
    let rawLeakersOnA = (effBeta  * state.bUnits) - yPoolA - params.decoyShiftA

    let deltaB: Int64
    let overkillA: Int64
    if rawLeakersOnB > 0 {
        deltaB = min(state.bUnits, rawLeakersOnB / max(1, params.xStay))
        overkillA = rawLeakersOnB % max(1, params.xStay)
    } else {
        deltaB = 0
        overkillA = 0
    }

    let deltaA: Int64
    let overkillB: Int64
    if rawLeakersOnA > 0 {
        deltaA = min(state.aUnits, rawLeakersOnA / max(1, params.wStay))
        overkillB = rawLeakersOnA % max(1, params.wStay)
    } else {
        deltaA = 0
        overkillB = 0
    }

    return CombatLatticeState(
        aUnits: state.aUnits - deltaA,
        bUnits: state.bUnits - deltaB,
        aMagazine: max(0, state.aMagazine - effAlpha),
        bMagazine: max(0, state.bMagazine - effBeta),
        aEnergy: max(0, state.aEnergy - params.metabolicBurnA),
        bEnergy: max(0, state.bEnergy - params.metabolicBurnB),
        aConnectivity: state.aConnectivity,
        bConnectivity: state.bConnectivity,
        tick: state.tick + 1,
        cumulativeOverkillA: state.cumulativeOverkillA + overkillA,
        cumulativeOverkillB: state.cumulativeOverkillB + overkillB
    )
}

public struct NodeSpectralProfile: Sendable, Equatable {
    public let nodeID: Int
    public let fiedlerCoordScaled: Int64
    public let stayingPowerX: Int64
    public let localDefenseZ: Int64
    public let spectralWeightPhi: Int64
}

public struct AllocationPlan: Sendable, Equatable {
    public let targetedNodeIDs: [Int]
    public let pulsesAllocatedPerNode: [Int: Int64]
    public let totalPulsesSpent: Int64
    public let quantizationOverkillResidual: Int64
    public let resultingSubgraphsM: Int64
}

public func allocateFiedlerSalvo(
    nodes: [NodeSpectralProfile],
    availableSalvoBudget: Int64,
    cooperativeDefensePoolBonus: Int64
) -> AllocationPlan {
    let sortedByFiedlerCut = nodes.sorted { $0.spectralWeightPhi > $1.spectralWeightPhi }

    var remainingBudget = availableSalvoBudget
    var targetedIDs: [Int] = []
    var allocation: [Int: Int64] = [:]
    var severedCuts: Int64 = 1

    for (index, node) in sortedByFiedlerCut.enumerated() {
        let activeCoopBonus = index == 0 ? cooperativeDefensePoolBonus : 0
        let exactKillCost = node.localDefenseZ + activeCoopBonus + node.stayingPowerX

        if remainingBudget >= exactKillCost && exactKillCost > 0 {
            targetedIDs.append(node.nodeID)
            allocation[node.nodeID] = exactKillCost
            remainingBudget -= exactKillCost
            if node.spectralWeightPhi > 512 {
                severedCuts += 1
            }
        }
    }

    return AllocationPlan(
        targetedNodeIDs: targetedIDs,
        pulsesAllocatedPerNode: allocation,
        totalPulsesSpent: availableSalvoBudget - remainingBudget,
        quantizationOverkillResidual: 0,
        resultingSubgraphsM: severedCuts
    )
}

public struct ThreatDefenseState: Sendable, Equatable {
    public var attackerEnergy: Int64
    public var closureDistanceCm: Int64
    public var intentVerified: Bool
    public var tarpitTicksElapsed: Int64
}

public enum DefensiveGameMove: Sendable {
    case outOfBandSeverance
    case checksumTarpitLoop
    case horizonFenceCommand
    case orthogonalKineticIntercept
}

public func evaluateDefenseStep(
    state: ThreatDefenseState,
    move: DefensiveGameMove,
    attackerClosureRate: Int64
) -> ThreatDefenseState {
    var next = state
    switch move {
    case .outOfBandSeverance:
        next.closureDistanceCm = 100_000
        next.intentVerified = true

    case .checksumTarpitLoop:
        next.tarpitTicksElapsed += 1
        next.attackerEnergy = max(0, state.attackerEnergy - 180)
        next.closureDistanceCm = max(300, state.closureDistanceCm)

    case .horizonFenceCommand:
        let nextDist = state.closureDistanceCm - attackerClosureRate
        next.closureDistanceCm = max(0, nextDist)
        if attackerClosureRate > 0 {
            next.intentVerified = true
        }

    case .orthogonalKineticIntercept:
        next.attackerEnergy = 0
        next.closureDistanceCm += 450
    }
    return next
}

public struct EncounterLatticeState: Sendable, Equatable {
    public var arousalAlpha: Int64
    public var bandwidthRho: Int64
    public var socialLambda2: Int64
    public var clarityIota: Int64
    public var tick: Int64

    public var kineticGuardH: Int64 {
        return arousalAlpha - bandwidthRho - (clarityIota / 2)
    }
}

public enum LanguageGameMove: Sendable {
    case oodaPatternInterrupt
    case affectLabelingStairway
    case proceduralJusticeLEAPS
    case boundedAutonomyChoice
    case symmetricDominanceUltimatum
}

public func stepLanguageGame(
    state: EncounterLatticeState,
    move: LanguageGameMove
) -> EncounterLatticeState {
    let dAlpha: Int64
    let dRho: Int64
    let dLambda: Int64
    let dIota: Int64

    switch move {
    case .oodaPatternInterrupt:
        dAlpha = -240; dRho = 210; dLambda = 120; dIota = 150
    case .affectLabelingStairway:
        dAlpha = -180; dRho = 160; dLambda = 280; dIota = 140
    case .proceduralJusticeLEAPS:
        dAlpha = -150; dRho = 140; dLambda = 190; dIota = 320
    case .boundedAutonomyChoice:
        dAlpha = -160; dRho = 250; dLambda = 210; dIota = 220
    case .symmetricDominanceUltimatum:
        dAlpha = 260;  dRho = -280; dLambda = -300; dIota = -150
    }

    let clamp = { (v: Int64) -> Int64 in min(1000, max(0, v)) }

    return EncounterLatticeState(
        arousalAlpha: clamp(state.arousalAlpha + dAlpha),
        bandwidthRho: clamp(state.bandwidthRho + dRho),
        socialLambda2: clamp(state.socialLambda2 + dLambda),
        clarityIota: clamp(state.clarityIota + dIota),
        tick: state.tick + 1
    )
}

public enum Study67PWASpectralCourt {
    public static func runFullVerification() {
        var fnvHash: UInt64 = 14695981039346656037
        func Mix(_ v: Int64) {
            let u = UInt64(bitPattern: v)
            for b in 0..<8 {
                fnvHash ^= (u >> UInt64(b * 8)) & 0xFF
                fnvHash = fnvHash &* 1099511628211
            }
        }

        let bNodes: Int64 = 12
        let cFocus: Int64 = 1
        let zLocal: Int64 = 8
        let incomingSalvo: Int64 = 48

        let poolFullCEC = computeEffectiveDefensePool(activeNodesB: bNodes, targetedNodesC: cFocus, localDefenseZ: zLocal, subgraphsM: 1, kappaConnectivity: 4096)
        let leakersFullCEC = max(0, incomingSalvo - poolFullCEC)
        let poolCompressed = computeEffectiveDefensePool(activeNodesB: bNodes, targetedNodesC: cFocus, localDefenseZ: zLocal, subgraphsM: 1, kappaConnectivity: 512)
        let leakersCompressed = max(0, incomingSalvo - poolCompressed)
        let poolSevered = computeEffectiveDefensePool(activeNodesB: bNodes, targetedNodesC: cFocus, localDefenseZ: zLocal, subgraphsM: 12, kappaConnectivity: 0)
        let leakersSevered = max(0, incomingSalvo - poolSevered)
        let kappaCrit = computeCriticalKappaThreshold(incomingSalvoOnB: incomingSalvo, activeNodesB: bNodes, targetedNodesC: cFocus, localDefenseZ: zLocal, subgraphsM: 1, decoyShiftB: 0)

        Mix(poolFullCEC); Mix(leakersFullCEC)
        Mix(poolCompressed); Mix(leakersCompressed)
        Mix(poolSevered); Mix(leakersSevered)
        Mix(kappaCrit)

        let lambda2_base: Int64 = 64
        let tau_base: Int64     = 32
        let poolEW = computeEffectiveDefensePool(activeNodesB: bNodes, targetedNodesC: cFocus, localDefenseZ: zLocal, subgraphsM: 1, kappaConnectivity: (lambda2_base / 2) * tau_base)
        let poolHypersonic = computeEffectiveDefensePool(activeNodesB: bNodes, targetedNodesC: cFocus, localDefenseZ: zLocal, subgraphsM: 1, kappaConnectivity: lambda2_base * (tau_base / 2))
        let isomorphismResidual = (poolEW - poolHypersonic)
        Mix(poolEW); Mix(poolHypersonic); Mix(isomorphismResidual)

        let baseParamsNoShift = AffineSalvoParameters(domainName: "Sea_No_bShift", alpha: 5, beta: 4, yDefenseLocal: 2, zDefenseLocal: 3, wStay: 3, xStay: 3, decoyShiftA: 0, decoyShiftB: 0, subgraphsMA: 1, subgraphsMB: 1, targetFocusCA: 2, targetFocusCB: 2, metabolicBurnA: 10, metabolicBurnB: 10, transportLagTau: 1)
        let baseParamsWithShift = AffineSalvoParameters(domainName: "Sea_With_bShift", alpha: 5, beta: 4, yDefenseLocal: 2, zDefenseLocal: 3, wStay: 3, xStay: 3, decoyShiftA: 28, decoyShiftB: 0, subgraphsMA: 1, subgraphsMB: 5, targetFocusCA: 2, targetFocusCB: 1, metabolicBurnA: 10, metabolicBurnB: 10, transportLagTau: 1)

        var stateNoShift = CombatLatticeState(aUnits: 6, bUnits: 10, aMagazine: 30, bMagazine: 30, aEnergy: 100, bEnergy: 100, aConnectivity: 2048, bConnectivity: 2048, tick: 0, cumulativeOverkillA: 0, cumulativeOverkillB: 0)
        var stateWithShift = CombatLatticeState(aUnits: 6, bUnits: 10, aMagazine: 30, bMagazine: 30, aEnergy: 100, bEnergy: 100, aConnectivity: 2048, bConnectivity: 128, tick: 0, cumulativeOverkillA: 0, cumulativeOverkillB: 0)

        while stateNoShift.aUnits > 0 && stateNoShift.bUnits > 0 && stateNoShift.tick < 8 {
            stateNoShift = stepAffineSalvo(state: stateNoShift, params: baseParamsNoShift)
        }
        while stateWithShift.aUnits > 0 && stateWithShift.bUnits > 0 && stateWithShift.tick < 8 {
            stateWithShift = stepAffineSalvo(state: stateWithShift, params: baseParamsWithShift)
        }
        Mix(stateNoShift.aUnits); Mix(stateNoShift.bUnits)
        Mix(stateWithShift.aUnits); Mix(stateWithShift.bUnits)

        let networkNodes: [NodeSpectralProfile] = [
            NodeSpectralProfile(nodeID: 1, fiedlerCoordScaled: -640, stayingPowerX: 2, localDefenseZ: 4, spectralWeightPhi: 220),
            NodeSpectralProfile(nodeID: 2, fiedlerCoordScaled: -310, stayingPowerX: 2, localDefenseZ: 4, spectralWeightPhi: 940),
            NodeSpectralProfile(nodeID: 3, fiedlerCoordScaled:  290, stayingPowerX: 2, localDefenseZ: 4, spectralWeightPhi: 880),
            NodeSpectralProfile(nodeID: 4, fiedlerCoordScaled:  620, stayingPowerX: 2, localDefenseZ: 4, spectralWeightPhi: 190),
            NodeSpectralProfile(nodeID: 5, fiedlerCoordScaled:  710, stayingPowerX: 2, localDefenseZ: 4, spectralWeightPhi: 140)
        ]
        let fiedlerPlan = allocateFiedlerSalvo(nodes: networkNodes, availableSalvoBudget: 28, cooperativeDefensePoolBonus: 6)
        Mix(fiedlerPlan.totalPulsesSpent); Mix(fiedlerPlan.quantizationOverkillResidual); Mix(fiedlerPlan.resultingSubgraphsM)

        var scamState = ThreatDefenseState(attackerEnergy: 1000, closureDistanceCm: 300, intentVerified: false, tarpitTicksElapsed: 0)
        for _ in 0..<6 {
            scamState = evaluateDefenseStep(state: scamState, move: .checksumTarpitLoop, attackerClosureRate: 60)
        }
        var kineticState = ThreatDefenseState(attackerEnergy: 1000, closureDistanceCm: 500, intentVerified: false, tarpitTicksElapsed: 0)
        kineticState = evaluateDefenseStep(state: kineticState, move: .horizonFenceCommand, attackerClosureRate: 320)
        kineticState = evaluateDefenseStep(state: kineticState, move: .orthogonalKineticIntercept, attackerClosureRate: 0)
        Mix(scamState.attackerEnergy); Mix(scamState.tarpitTicksElapsed)
        Mix(kineticState.closureDistanceCm); Mix(kineticState.attackerEnergy)

        let initialCrisis = EncounterLatticeState(arousalAlpha: 820, bandwidthRho: 240, socialLambda2: 180, clarityIota: 200, tick: 0)
        let hInitial = initialCrisis.kineticGuardH
        var deescalated = stepLanguageGame(state: initialCrisis, move: .oodaPatternInterrupt)
        deescalated = stepLanguageGame(state: deescalated, move: .affectLabelingStairway)
        deescalated = stepLanguageGame(state: deescalated, move: .proceduralJusticeLEAPS)
        deescalated = stepLanguageGame(state: deescalated, move: .boundedAutonomyChoice)
        let hDeescalated = deescalated.kineticGuardH
        let escalated = stepLanguageGame(state: initialCrisis, move: .symmetricDominanceUltimatum)
        let hEscalated = escalated.kineticGuardH
        Mix(hInitial); Mix(hDeescalated); Mix(hEscalated)

        print("STUDY67_UNIFIED_PWA_SPECTRAL_AND_LANGUAGE_GAME_COURT")
        print("  state_manifold                     = M_8 = S^4(x1,x2,x3,tau) x C^4(mu,delta,epsilon,kappa) subset Z^8")
        print("  pillar1_spectral_regimes           = FullCEC:\(poolFullCEC) (0 leakers) | Compressed:\(poolCompressed) (11 leakers) | Severed:\(poolSevered) (40 leakers)")
        print("  pillar1_critical_fiedler_kappa     = \(kappaCrit) / 1024 (canonical rational = \(kappaCrit / binaryGCD(kappaCrit, 1024))/\(1024 / binaryGCD(kappaCrit, 1024)))")
        print("  pillar1_ew_mach8_isomorphism       = \(isomorphismResidual) (pool_EW:\(poolEW) == pool_Mach8:\(poolHypersonic) -> EXACT_ALGEBRAIC_ISOMORPHISM)")
        print("  pillar1_b_shift_dominance          = without_b:(A=\(stateNoShift.aUnits), B=\(stateNoShift.bUnits)) -> with_b_D_A=28:(A=\(stateWithShift.aUnits), B=\(stateWithShift.bUnits))")
        print("  pillar2_fiedler_cut_ilp            = targeted:\(fiedlerPlan.targetedNodeIDs) pulses_spent:\(fiedlerPlan.totalPulsesSpent)/28 subgraphs_m:\(fiedlerPlan.resultingSubgraphsM) overkill_residual:\(fiedlerPlan.quantizationOverkillResidual)")
        print("  pillar3_scammer_tarpit_exhaustion  = ticks:\(scamState.tarpitTicksElapsed) (+1080s delay) scammer_roi_remaining:\(scamState.attackerEnergy)/1000 (EXHAUSTED)")
        print("  pillar3_kinetic_horizon_intercept  = intent_verified:\(kineticState.intentVerified) assailant_energy:\(kineticState.attackerEnergy) reset_distance_cm:\(kineticState.closureDistanceCm)")
        print("  pillar4_deescalation_hyperplane_H  = initial_H:+\(hInitial) (CRITICAL) -> 4_step_LEAPS_H:\(hDeescalated) (SAFE < 0) vs ultimatum_H:+\(hEscalated)")
        print("  study67_fnv1a_seal                 = \(hex16(fnvHash))")
    }
}

Study67PWASpectralCourt.runFullVerification()