public interface ShooterIO {

    // ── Inputs: all sensor data the subsystem reads from this mechanism ────────
    // This class is a plain data container — no logic, only fields.
    // It's populated by updateInputs() and passed back to the subsystem.
    // Making it a nested class keeps all IO types for this subsystem in one file.
    class ShooterIOInputs {
        public double velocityRpm       = 0.0;
        public double appliedVolts      = 0.0;
        public double currentAmps       = 0.0;
        public double temperatureCelsius = 0.0;
        public boolean motorConnected   = false;
    }

    // ── updateInputs: called once per loop to populate sensor readings ─────────
    // Each implementation fills the inputs object from its data source:
    // - RealIO: reads from TalonFX signal API
    // - SimIO: reads from physics model state
    // - ReplayIO: reads from the log file
    //
    // After updateInputs(), the subsystem logs ALL inputs before using any of them.
    // This is what enables deterministic replay (Lesson 3).
    default void updateInputs(ShooterIOInputs inputs) {}

    // ── Output methods: commands the subsystem sends to the mechanism ──────────
    default void setVoltage(double volts) {}
    default void setVelocity(double velocityRpm, double ffVolts) {}
    default void stop() {}
}

import com.ctre.phoenix6.hardware.TalonFX;
import com.ctre.phoenix6.controls.*;

public class ShooterIOTalonFX implements ShooterIO {

    private final TalonFX m_motor = new TalonFX(11);
    private final VelocityVoltage m_velocityCtrl = new VelocityVoltage(0);
    private final VoltageOut      m_voltageCtrl  = new VoltageOut(0);

    public ShooterIOTalonFX() {
        // Configure motor — current limits, sensor source, direction
        var config = new TalonFXConfiguration();
        config.CurrentLimits.SupplyCurrentLimit = 40;
        config.CurrentLimits.SupplyCurrentLimitEnable = true;
        m_motor.getConfigurator().apply(config);
    }

    @Override
    public void updateInputs(ShooterIOInputs inputs) {
        // Read fresh sensor data from TalonFX signals
        // Phoenix 6 signals are cached — reading them here is cheap
        inputs.velocityRpm       = m_motor.getVelocity().getValueAsDouble() * 60;
        inputs.appliedVolts      = m_motor.getMotorVoltage().getValueAsDouble();
        inputs.currentAmps       = m_motor.getSupplyCurrent().getValueAsDouble();
        inputs.temperatureCelsius = m_motor.getDeviceTemp().getValueAsDouble();
        inputs.motorConnected    = m_motor.isAlive();
    }

    @Override
    public void setVelocity(double velocityRpm, double ffVolts) {
        m_motor.setControl(m_velocityCtrl
            .withVelocity(velocityRpm / 60.0)
            .withFeedForward(ffVolts));
    }

    @Override
    public void setVoltage(double volts) {
        m_motor.setControl(m_voltageCtrl.withOutput(volts));
    }

    @Override
    public void stop() { m_motor.stopMotor(); }
}

import edu.wpi.first.math.system.plant.DCMotor;
import edu.wpi.first.wpilibj.simulation.FlywheelSim;

public class ShooterIOSim implements ShooterIO {

    // FlywheelSim models the physics of a spinning flywheel:
    // motor type, gear ratio, moment of inertia (kg·m²)
    // Higher MOI = spins up and down more slowly (more flywheel mass)
    private final FlywheelSim m_sim = new FlywheelSim(
        DCMotor.getKrakenX60(1),    // motor model
        1.5,                          // gear ratio (motor : flywheel)
        0.004                         // flywheel MOI (kg·m²) — tune to match real spin-up time
    );

    private double m_appliedVolts = 0.0;

    @Override
    public void updateInputs(ShooterIOInputs inputs) {
        // Step the physics simulation forward by one 20ms loop
        m_sim.setInputVoltage(m_appliedVolts);
        m_sim.update(0.020);

        // Populate inputs from simulated state
        inputs.velocityRpm    = m_sim.getAngularVelocityRPM();
        inputs.appliedVolts   = m_appliedVolts;
        inputs.currentAmps    = m_sim.getCurrentDrawAmps();
        inputs.motorConnected = true;    // always "connected" in sim
    }

    @Override
    public void setVoltage(double volts) {
        // Clamp to ±12V (battery limit)
        m_appliedVolts = MathUtil.clamp(volts, -12.0, 12.0);
    }

    @Override
    public void setVelocity(double velocityRpm, double ffVolts) {
        // For closed-loop sim, apply the feedforward voltage directly.
        // The subsystem's PID controller adds correction on top of this.
        m_appliedVolts = MathUtil.clamp(ffVolts, -12.0, 12.0);
    }

    @Override
    public void stop() { m_appliedVolts = 0.0; }
}

public class Shooter extends SubsystemBase {

    private final ShooterIO       m_io;
    private final ShooterIOInputs m_inputs = new ShooterIOInputs();

    private final PIDController m_pid = new PIDController(0.0001, 0, 0);
    private final SimpleMotorFeedforward m_ff =
        new SimpleMotorFeedforward(0.1, 0.0025);

    private double m_targetRpm = 0.0;

    // Constructor takes the IO interface — subsystem doesn't care which implementation
    public Shooter(ShooterIO io) {
        m_io = io;
    }

    @Override
    public void periodic() {
        // Step 1: Update inputs from IO (hardware, sim, or log)
        // This MUST happen first, before any logic reads m_inputs.
        m_io.updateInputs(m_inputs);

        // Step 2: Log ALL inputs to AdvantageKit (before any reads).
        // Logger.processInputs() is what enables deterministic replay.
        // Covered in depth in Lesson 2 (AdvantageKit intro).
        Logger.processInputs("Shooter", m_inputs);

        // Step 3: Run control logic using inputs — same code for real/sim/replay
        if (m_targetRpm > 0) {
            double ffVolts  = m_ff.calculate(m_targetRpm);
            double pidVolts = m_pid.calculate(m_inputs.velocityRpm, m_targetRpm);
            m_io.setVelocity(m_targetRpm, ffVolts + pidVolts);
        }

        // Log outputs for debugging (covered in Lesson 2)
        Logger.recordOutput("Shooter/TargetRpm", m_targetRpm);
        Logger.recordOutput("Shooter/ActualRpm", m_inputs.velocityRpm);
        Logger.recordOutput("Shooter/AtSpeed", isAtTargetSpeed());
    }

    public void setTargetRpm(double rpm) { m_targetRpm = rpm; }
    public void stop() { m_targetRpm = 0; m_io.stop(); }

    public boolean isAtTargetSpeed() {
        return Math.abs(m_inputs.velocityRpm - m_targetRpm) < 50;
    }

    public double getVelocityRpm() { return m_inputs.velocityRpm; }
}

import edu.wpi.first.wpilibj.RobotBase;

public class RobotContainer {

    private final Shooter m_shooter;

    public RobotContainer() {
        if (RobotBase.isReal()) {
            // Running on physical robot hardware
            m_shooter = new Shooter(new ShooterIOTalonFX());
        } else if (Constants.isReplay) {
            // Replaying a previously recorded match log (AdvantageKit replay)
            // ShooterIOReplay has empty updateInputs() — AdvantageKit overwrites
            // m_inputs directly from the log before periodic() runs.
            m_shooter = new Shooter(new ShooterIOReplay());
        } else {
            // Running in simulation on a laptop (no hardware)
            m_shooter = new Shooter(new ShooterIOSim());
        }

        configureBindings();
    }
}