/*
 * Copyright (c) 2018-2022 REV Robotics
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of REV Robotics nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

package com.revrobotics;

import com.revrobotics.jni.CANSparkMaxJNI;

public class CANSparkMax extends CANSparkMaxLowLevel {
  public enum IdleMode {
    kCoast(0),
    kBrake(1);

    @SuppressWarnings("MemberName")
    public final int value;

    IdleMode(int value) {
      this.value = value;
    }

    public static IdleMode fromId(int id) {
      if (id == 1) {
        return kBrake;
      }
      return kCoast;
    }
  }

  @Deprecated(forRemoval = true)
  public enum InputMode {
    kPWM(0),
    kCAN(1);

    @SuppressWarnings("MemberName")
    public final int value;

    InputMode(int value) {
      this.value = value;
    }

    public static InputMode fromId(int id) {
      if (id == 1) {
        return kCAN;
      }
      return kPWM;
    }
  }

  public enum SoftLimitDirection {
    kForward(0),
    kReverse(1);

    @SuppressWarnings("MemberName")
    public final int value;

    SoftLimitDirection(int value) {
      this.value = value;
    }

    public static SoftLimitDirection fromID(int id) {
      if (id == 1) {
        return kReverse;
      }
      return kForward;
    }
  }

  public enum FaultID {
    kBrownout(0),
    kOvercurrent(1),
    kIWDTReset(2),
    kMotorFault(3),
    kSensorFault(4),
    kStall(5),
    kEEPROMCRC(6),
    kCANTX(7),
    kCANRX(8),
    kHasReset(9),
    kDRVFault(10),
    kOtherFault(11),
    kSoftLimitFwd(12),
    kSoftLimitRev(13),
    kHardLimitFwd(14),
    kHardLimitRev(15);

    @SuppressWarnings("MemberName")
    public final int value;

    FaultID(int value) {
      this.value = value;
    }

    public static FaultID fromId(int id) {
      for (FaultID type : values()) {
        if (type.value == id) {
          return type;
        }
      }
      return null;
    }
  }

  public enum ControlType {
    kDutyCycle(0),
    kVelocity(1),
    kVoltage(2),
    kPosition(3),
    kSmartMotion(4),
    kCurrent(5),
    kSmartVelocity(6);

    @SuppressWarnings("MemberName")
    public final int value;

    ControlType(int value) {
      this.value = value;
    }
  }

  public static class ExternalFollower {
    private final int arbId;
    private final int configId;

    public static final ExternalFollower kFollowerDisabled = new ExternalFollower(0, 0);
    public static final ExternalFollower kFollowerSparkMax = new ExternalFollower(0x2051800, 26);
    public static final ExternalFollower kFollowerPhoenix = new ExternalFollower(0x2040080, 27);

    public ExternalFollower(int arbId, int configId) {
      this.arbId = arbId;
      this.configId = configId;
    }
  }

  private SparkMaxRelativeEncoder encoder;
  private final Object encoderLock = new Object();

  private SparkMaxAlternateEncoder altEncoder;
  private final Object altEncoderLock = new Object();

  private SparkMaxAnalogSensor analogSensor;
  private final Object analogSensorLock = new Object();

  private SparkMaxPIDController pidController;
  private final Object pidControllerLock = new Object();

  private SparkMaxLimitSwitch forwardLimitSwitch;
  private final Object forwardLimitSwitchLock = new Object();

  private SparkMaxLimitSwitch reverseLimitSwitch;
  private final Object reverseLimitSwitchLock = new Object();

  // Only used for get() and set() API
  private double m_setpoint = 0.0;

  /**
   * Create a new object to control a SPARK MAX motor Controller
   *
   * @param deviceId The device ID.
   * @param type The motor type connected to the controller. Brushless motor wires must be connected
   *     to their matching colors and the hall sensor must be plugged in. Brushed motors must be
   *     connected to the Red and Black terminals only.
   */
  public CANSparkMax(int deviceId, MotorType type) {
    super(deviceId, type);
  }

  /** ** Speed Controller Interface *** */
  /**
   * Common interface for setting the speed of a speed controller.
   *
   * @param speed The speed to set. Value should be between -1.0 and 1.0.
   */
  @Override
  public void set(double speed) {
    throwIfClosed();
    // Only for 'get' API
    m_setpoint = speed;
    setpointCommand(speed, ControlType.kDutyCycle);
  }

  /**
   * Sets the voltage output of the SpeedController. This is equivillant to a call to
   * SetReference(output, rev::ControlType::kVoltage). The behavior of this call differs slightly
   * from the WPILib documetation for this call since the device internally sets the desired voltage
   * (not a compensation value). That means that this *can* be a 'set-and-forget' call.
   *
   * @param outputVolts The voltage to output.
   */
  @Override
  public void setVoltage(double outputVolts) {
    throwIfClosed();
    setpointCommand(outputVolts, ControlType.kVoltage);
  }

  /**
   * Common interface for getting the current set speed of a speed controller.
   *
   * @return The current set speed. Value is between -1.0 and 1.0.
   */
  @Override
  public double get() {
    throwIfClosed();
    return m_setpoint;
  }

  /**
   * Common interface for inverting direction of a speed controller.
   *
   * <p>This call has no effect if the controller is a follower. To invert a follower, see the
   * follow() method.
   *
   * @param isInverted The state of inversion, true is inverted.
   */
  @Override
  public void setInverted(boolean isInverted) {
    throwIfClosed();
    CANSparkMaxJNI.c_SparkMax_SetInverted(sparkMaxHandle, isInverted);
  }

  /**
   * Common interface for returning the inversion state of a speed controller.
   *
   * <p>This call has no effect if the controller is a follower.
   *
   * @return isInverted The state of inversion, true is inverted.
   */
  @Override
  public boolean getInverted() {
    throwIfClosed();
    return CANSparkMaxJNI.c_SparkMax_GetInverted(sparkMaxHandle);
  }

  /** Common interface for disabling a motor. */
  @Override
  public void disable() {
    throwIfClosed();
    set(0);
  }

  @Override
  public void stopMotor() {
    throwIfClosed();
    set(0);
  }

  /** ***** Extended Functions ****** */
  /**
   * Returns an object for interfacing with the hall sensor integrated into a brushless motor, which
   * is connected to the front port of the SPARK MAX.
   *
   * <p>To access a quadrature encoder connected to the encoder pins or the front port of the SPARK
   * MAX, you must call the version of this method with EncoderType and countsPerRev parameters.
   *
   * @return An object for interfacing with the integrated encoder.
   */
  public RelativeEncoder getEncoder() {
    throwIfClosed();
    return getEncoder(SparkMaxRelativeEncoder.Type.kHallSensor, 42);
  }

  /**
   * Returns an object for interfacing with the encoder connected to the encoder pins or front port
   * of the SPARK MAX.
   *
   * @param encoderType The encoder type for the motor: kHallEffect or kQuadrature
   * @param countsPerRev The counts per revolution of the encoder
   * @return An object for interfacing with an encoder
   */
  public RelativeEncoder getEncoder(SparkMaxRelativeEncoder.Type encoderType, int countsPerRev) {
    throwIfClosed();
    synchronized (encoderLock) {
      if (encoder == null) {
        encoder = new SparkMaxRelativeEncoder(this, encoderType, countsPerRev);
      } else {
        if (encoder.type != encoderType) {
          throw new IllegalStateException(
              "The main encoder on this SPARK MAX has already been initialized as a "
                  + encoder.type);
        }
        // Counts per revolution is ignored for the hall sensor encoder type
        if (encoder.type != SparkMaxRelativeEncoder.Type.kHallSensor
            && encoder.getCountsPerRevolution() != countsPerRev) {
          throw new IllegalStateException(
              "The main encoder on this SPARK MAX has already been initialized with countsPerRev set to "
                  + encoder.countsPerRev);
        }
        // The user isn't trying to change their encoder settings mid-program, so we're all set
      }
      return encoder;
    }
  }

  /**
   * Returns an object for interfacing with the encoder connected to the encoder pins or front port
   * of the SPARK MAX.
   *
   * @param encoderType The encoder type for the motor: kHallEffect or kQuadrature
   * @param countsPerRev The counts per revolution of the encoder
   * @return An object for interfacing with an encoder
   * @deprecated Use {@link #getEncoder(SparkMaxRelativeEncoder.Type, int)} instead.
   */
  @SuppressWarnings("removal")
  @Deprecated(forRemoval = true)
  public RelativeEncoder getEncoder(com.revrobotics.EncoderType encoderType, int countsPerRev) {
    SparkMaxRelativeEncoder.Type adaptedType = SparkMaxRelativeEncoder.Type.kNoSensor;
    if (encoderType == com.revrobotics.EncoderType.kHallSensor) {
      adaptedType = SparkMaxRelativeEncoder.Type.kHallSensor;
    } else if (encoderType == com.revrobotics.EncoderType.kQuadrature) {
      adaptedType = SparkMaxRelativeEncoder.Type.kQuadrature;
    }
    return getEncoder(adaptedType, countsPerRev);
  }

  /**
   * Returns an object for interfacing with a quadrature encoder connected to the alternate encoder
   * mode data port pins. These are defined as:
   *
   * <ul>
   *   <li>Pin 4 (Forward Limit Switch): Index
   *   <li>Pin 6 (Multi-function): Encoder A
   *   <li>Pin 8 (Reverse Limit Switch): Encoder B
   * </ul>
   *
   * <p>This call will disable support for the limit switch inputs.
   *
   * @param countsPerRev The counts per revolution of the encoder
   * @return An object for interfacing with a quadrature encoder connected to the alternate encoder
   *     mode data port pins
   */
  public RelativeEncoder getAlternateEncoder(int countsPerRev) {
    throwIfClosed();
    return getAlternateEncoder(SparkMaxAlternateEncoder.Type.kQuadrature, countsPerRev);
  }

  /**
   * Returns an object for interfacing with a quadrature encoder connected to the alternate encoder
   * mode data port pins. These are defined as:
   *
   * <ul>
   *   <li>Pin 4 (Forward Limit Switch): Index
   *   <li>Pin 6 (Multi-function): Encoder A
   *   <li>Pin 8 (Reverse Limit Switch): Encoder B
   * </ul>
   *
   * <p>This call will disable support for the limit switch inputs.
   *
   * @param encoderType The encoder type for the motor: currently only kQuadrature
   * @param countsPerRev The counts per revolution of the encoder
   * @return An object for interfacing with a quadrature encoder connected to the alternate encoder
   *     mode data port pins
   */
  public RelativeEncoder getAlternateEncoder(
      SparkMaxAlternateEncoder.Type encoderType, int countsPerRev) {
    throwIfClosed();
    synchronized (altEncoderLock) {
      if (altEncoder == null) {
        altEncoder = new SparkMaxAlternateEncoder(this, encoderType, countsPerRev);
      } else {
        if (altEncoder.type != encoderType) {
          throw new IllegalStateException(
              "The alternate encoder on this SPARK MAX has already been initialized as a "
                  + altEncoder.type);
        }
        if (altEncoder.countsPerRev != countsPerRev) {
          throw new IllegalStateException(
              "The alternate encoder on this SPARK MAX has already been initialized with countsPerRev set to "
                  + altEncoder.countsPerRev);
        }
        // The user isn't trying to change their alternate encoder settings mid-program,
        // so we're all set
      }
      return altEncoder;
    }
  }

  /**
   * Returns an object for interfacing with a quadrature encoder connected to the alternate encoder
   * mode data port pins. These are defined as:
   *
   * <ul>
   *   <li>Pin 4 (Forward Limit Switch): Index
   *   <li>Pin 6 (Multi-function): Encoder A
   *   <li>Pin 8 (Reverse Limit Switch): Encoder B
   * </ul>
   *
   * <p>This call will disable support for the limit switch inputs.
   *
   * @param encoderType The encoder type for the motor: currently only kQuadrature
   * @param countsPerRev The counts per revolution of the encoder
   * @return An object for interfacing with a quadrature encoder connected to the alternate encoder
   *     mode data port pins
   */
  @SuppressWarnings("removal")
  @Deprecated(forRemoval = true)
  public RelativeEncoder getAlternateEncoder(
      com.revrobotics.AlternateEncoderType encoderType, int countsPerRev) {
    return getAlternateEncoder(SparkMaxAlternateEncoder.Type.kQuadrature, countsPerRev);
  }

  /**
   * @param mode The mode of the analog sensor, either absolute or relative
   * @return An object for interfacing with a connected analog sensor.
   */
  public SparkMaxAnalogSensor getAnalog(SparkMaxAnalogSensor.Mode mode) {
    throwIfClosed();
    synchronized (analogSensorLock) {
      if (analogSensor == null) {
        analogSensor = new SparkMaxAnalogSensor(this, mode);
      } else {
        if (analogSensor.mode != mode) {
          throw new IllegalStateException(
              "The analog sensor connected to this SPARK MAX has already been configured with mode "
                  + analogSensor.mode);
        }
        // The user isn't trying to change their analog sensor settings mid-program,
        // so we're all set
      }
      return analogSensor;
    }
  }

  /** @deprecated Use {@link #getAnalog(SparkMaxAnalogSensor.Mode)} instead */
  @SuppressWarnings("removal")
  @Deprecated(forRemoval = true)
  public SparkMaxAnalogSensor getAnalog(CANAnalog.AnalogMode mode) {
    SparkMaxAnalogSensor.Mode newMode;
    if (mode == CANAnalog.AnalogMode.kRelative) {
      newMode = SparkMaxAnalogSensor.Mode.kRelative;
    } else {
      newMode = SparkMaxAnalogSensor.Mode.kAbsolute;
    }
    return getAnalog(newMode);
  }

  /** @return An object for interfacing with the integrated PID controller. */
  public SparkMaxPIDController getPIDController() {
    throwIfClosed();
    synchronized (pidControllerLock) {
      if (pidController == null) {
        pidController = new SparkMaxPIDController(this);
      }
      return pidController;
    }
  }

  /**
   * Returns an object for interfacing with the forward limit switch connected to the appropriate
   * pins on the data port.
   *
   * <p>This call will disable support for the alternate encoder.
   *
   * @param polarity Whether the limit switch is normally open or normally closed.
   * @return An object for interfacing with the forward limit switch.
   * @deprecated Use {@link #getForwardLimitSwitch(SparkMaxLimitSwitch.Type)} instead.
   */
  @SuppressWarnings("removal")
  @Deprecated(forRemoval = true)
  public CANDigitalInput getForwardLimitSwitch(CANDigitalInput.LimitSwitchPolarity polarity) {
    SparkMaxLimitSwitch.Type newType;
    if (polarity == CANDigitalInput.LimitSwitchPolarity.kNormallyClosed) {
      newType = SparkMaxLimitSwitch.Type.kNormallyClosed;
    } else {
      newType = SparkMaxLimitSwitch.Type.kNormallyOpen;
    }

    return getForwardLimitSwitch(newType);
  }

  /**
   * Returns an object for interfacing with the forward limit switch connected to the appropriate
   * pins on the data port.
   *
   * <p>This call will disable support for the alternate encoder.
   *
   * @param switchType Whether the limit switch is normally open or normally closed.
   * @return An object for interfacing with the forward limit switch.
   */
  public SparkMaxLimitSwitch getForwardLimitSwitch(SparkMaxLimitSwitch.Type switchType) {
    throwIfClosed();
    synchronized (forwardLimitSwitchLock) {
      if (forwardLimitSwitch == null) {
        forwardLimitSwitch =
            new SparkMaxLimitSwitch(this, SparkMaxLimitSwitch.Direction.kForward, switchType);
      } else {
        if (forwardLimitSwitch.m_switchType != switchType) {
          throw new IllegalStateException(
              "The forward limit switch on this SPARK MAX has already been configured with the"
                  + forwardLimitSwitch.m_switchType
                  + " switch type");
        }
      }
      return forwardLimitSwitch;
    }
  }

  /**
   * Returns an object for interfacing with the reverse limit switch connected to the appropriate
   * pins on the data port.
   *
   * <p>This call will disable support for the alternate encoder.
   *
   * @param polarity Whether the limit switch is normally open or normally closed.
   * @return An object for interfacing with the reverse limit switch.
   * @deprecated Use {@link #getReverseLimitSwitch(SparkMaxLimitSwitch.Type)} instead.
   */
  @SuppressWarnings("removal")
  @Deprecated(forRemoval = true)
  public CANDigitalInput getReverseLimitSwitch(CANDigitalInput.LimitSwitchPolarity polarity) {
    SparkMaxLimitSwitch.Type newType;
    if (polarity == CANDigitalInput.LimitSwitchPolarity.kNormallyClosed) {
      newType = SparkMaxLimitSwitch.Type.kNormallyClosed;
    } else {
      newType = SparkMaxLimitSwitch.Type.kNormallyOpen;
    }

    return getReverseLimitSwitch(newType);
  }

  /**
   * Returns an object for interfacing with the reverse limit switch connected to the appropriate
   * pins on the data port.
   *
   * <p>This call will disable support for the alternate encoder.
   *
   * @param switchType Whether the limit switch is normally open or normally closed.
   * @return An object for interfacing with the reverse limit switch.
   */
  public SparkMaxLimitSwitch getReverseLimitSwitch(SparkMaxLimitSwitch.Type switchType) {
    throwIfClosed();
    synchronized (reverseLimitSwitchLock) {
      if (reverseLimitSwitch == null) {
        reverseLimitSwitch =
            new SparkMaxLimitSwitch(this, SparkMaxLimitSwitch.Direction.kReverse, switchType);
      } else {
        if (reverseLimitSwitch.m_switchType != switchType) {
          throw new IllegalStateException(
              "The reverse limit switch on this SPARK MAX has already been configured with the "
                  + reverseLimitSwitch.m_switchType
                  + " switch type");
        }
      }
      return reverseLimitSwitch;
    }
  }

  /**
   * Sets the current limit in Amps.
   *
   * <p>The motor controller will reduce the controller voltage output to avoid surpassing this
   * limit. This limit is enabled by default and used for brushless only. This limit is highly
   * recommended when using the NEO brushless motor.
   *
   * <p>The NEO Brushless Motor has a low internal resistance, which can mean large current spikes
   * that could be enough to cause damage to the motor and controller. This current limit provides a
   * smarter strategy to deal with high current draws and keep the motor and controller operating in
   * a safe region.
   *
   * @param limit The current limit in Amps.
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError setSmartCurrentLimit(int limit) {
    throwIfClosed();
    return setSmartCurrentLimit(limit, 0, 20000);
  }

  /**
   * Sets the current limit in Amps.
   *
   * <p>The motor controller will reduce the controller voltage output to avoid surpassing this
   * limit. This limit is enabled by default and used for brushless only. This limit is highly
   * recommended when using the NEO brushless motor.
   *
   * <p>The NEO Brushless Motor has a low internal resistance, which can mean large current spikes
   * that could be enough to cause damage to the motor and controller. This current limit provides a
   * smarter strategy to deal with high current draws and keep the motor and controller operating in
   * a safe region.
   *
   * <p>The controller can also limit the current based on the RPM of the motor in a linear fashion
   * to help with controllability in closed loop control. For a response that is linear the entire
   * RPM range leave limit RPM at 0.
   *
   * @param stallLimit The current limit in Amps at 0 RPM.
   * @param freeLimit The current limit at free speed (5700RPM for NEO).
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError setSmartCurrentLimit(int stallLimit, int freeLimit) {
    throwIfClosed();
    return setSmartCurrentLimit(stallLimit, freeLimit, 20000);
  }

  /**
   * Sets the current limit in Amps.
   *
   * <p>The motor controller will reduce the controller voltage output to avoid surpassing this
   * limit. This limit is enabled by default and used for brushless only. This limit is highly
   * recommended when using the NEO brushless motor.
   *
   * <p>The NEO Brushless Motor has a low internal resistance, which can mean large current spikes
   * that could be enough to cause damage to the motor and controller. This current limit provides a
   * smarter strategy to deal with high current draws and keep the motor and controller operating in
   * a safe region.
   *
   * <p>The controller can also limit the current based on the RPM of the motor in a linear fashion
   * to help with controllability in closed loop control. For a response that is linear the entire
   * RPM range leave limit RPM at 0.
   *
   * @param stallLimit The current limit in Amps at 0 RPM.
   * @param freeLimit The current limit at free speed (5700RPM for NEO).
   * @param limitRPM RPM less than this value will be set to the stallLimit, RPM values greater than
   *     limitRPM will scale linearly to freeLimit
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError setSmartCurrentLimit(int stallLimit, int freeLimit, int limitRPM) {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_SetSmartCurrentLimit(
            sparkMaxHandle, stallLimit, freeLimit, limitRPM));
  }

  /**
   * Sets the secondary current limit in Amps.
   *
   * <p>The motor controller will disable the output of the controller briefly if the current limit
   * is exceeded to reduce the current. This limit is a simplified 'on/off' controller. This limit
   * is enabled by default but is set higher than the default Smart Current Limit.
   *
   * <p>The time the controller is off after the current limit is reached is determined by the
   * parameter limitCycles, which is the number of PWM cycles (20kHz). The recommended value is the
   * default of 0 which is the minimum time and is part of a PWM cycle from when the over current is
   * detected. This allows the controller to regulate the current close to the limit value.
   *
   * <p>The total time is set by the equation <code>
   * t = (50us - t0) + 50us * limitCycles
   * t = total off time after over current
   * t0 = time from the start of the PWM cycle until over current is detected
   * </code>
   *
   * @param limit The current limit in Amps.
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError setSecondaryCurrentLimit(double limit) {
    throwIfClosed();
    return setSecondaryCurrentLimit(limit, 0);
  }

  /**
   * Sets the secondary current limit in Amps.
   *
   * <p>The motor controller will disable the output of the controller briefly if the current limit
   * is exceeded to reduce the current. This limit is a simplified 'on/off' controller. This limit
   * is enabled by default but is set higher than the default Smart Current Limit.
   *
   * <p>The time the controller is off after the current limit is reached is determined by the
   * parameter limitCycles, which is the number of PWM cycles (20kHz). The recommended value is the
   * default of 0 which is the minimum time and is part of a PWM cycle from when the over current is
   * detected. This allows the controller to regulate the current close to the limit value.
   *
   * <p>The total time is set by the equation <code>
   * t = (50us - t0) + 50us * limitCycles
   * t = total off time after over current
   * t0 = time from the start of the PWM cycle until over current is detected
   * </code>
   *
   * @param limit The current limit in Amps.
   * @param chopCycles The number of additional PWM cycles to turn the driver off after overcurrent
   *     is detected.
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError setSecondaryCurrentLimit(double limit, int chopCycles) {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_SetSecondaryCurrentLimit(
            sparkMaxHandle, (float) limit, chopCycles));
  }

  /**
   * Sets the idle mode setting for the SPARK MAX.
   *
   * @param mode Idle mode (coast or brake).
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError setIdleMode(IdleMode mode) {
    throwIfClosed();
    return REVLibError.fromInt(CANSparkMaxJNI.c_SparkMax_SetIdleMode(sparkMaxHandle, mode.value));
  }

  /**
   * Gets the idle mode setting for the SPARK MAX.
   *
   * <p>This uses the Get Parameter API and should be used infrequently. This function uses a
   * non-blocking call and will return a cached value if the parameter is not returned by the
   * timeout. The timeout can be changed by calling SetCANTimeout(int milliseconds)
   *
   * @return IdleMode Idle mode setting
   */
  public IdleMode getIdleMode() {
    throwIfClosed();
    return IdleMode.fromId(CANSparkMaxJNI.c_SparkMax_GetIdleMode(sparkMaxHandle));
  }

  /**
   * Sets the voltage compensation setting for all modes on the SPARK MAX and enables voltage
   * compensation.
   *
   * @param nominalVoltage Nominal voltage to compensate output to
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError enableVoltageCompensation(double nominalVoltage) {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_EnableVoltageCompensation(
            sparkMaxHandle, (float) nominalVoltage));
  }

  /**
   * Disables the voltage compensation setting for all modes on the SPARK MAX.
   *
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError disableVoltageCompensation() {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_DisableVoltageCompensation(sparkMaxHandle));
  }

  /**
   * Get the configured voltage compensation nominal voltage value
   *
   * @return The nominal voltage for voltage compensation mode.
   */
  public double getVoltageCompensationNominalVoltage() {
    throwIfClosed();
    return (double) CANSparkMaxJNI.c_SparkMax_GetVoltageCompensationNominalVoltage(sparkMaxHandle);
  }

  /**
   * Sets the ramp rate for open loop control modes.
   *
   * <p>This is the maximum rate at which the motor controller's output is allowed to change.
   *
   * @param rate Time in seconds to go from 0 to full throttle.
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError setOpenLoopRampRate(double rate) {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_SetOpenLoopRampRate(sparkMaxHandle, (float) rate));
  }

  /**
   * Sets the ramp rate for closed loop control modes.
   *
   * <p>This is the maximum rate at which the motor controller's output is allowed to change.
   *
   * @param rate Time in seconds to go from 0 to full throttle.
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError setClosedLoopRampRate(double rate) {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_SetClosedLoopRampRate(sparkMaxHandle, (float) rate));
  }

  /**
   * Get the configured open loop ramp rate
   *
   * <p>This is the maximum rate at which the motor controller's output is allowed to change.
   *
   * @return ramp rate time in seconds to go from 0 to full throttle.
   */
  public double getOpenLoopRampRate() {
    throwIfClosed();
    return (double) CANSparkMaxJNI.c_SparkMax_GetOpenLoopRampRate(sparkMaxHandle);
  }

  /**
   * Get the configured closed loop ramp rate
   *
   * <p>This is the maximum rate at which the motor controller's output is allowed to change.
   *
   * @return ramp rate time in seconds to go from 0 to full throttle.
   */
  public double getClosedLoopRampRate() {
    throwIfClosed();
    return (double) CANSparkMaxJNI.c_SparkMax_GetClosedLoopRampRate(sparkMaxHandle);
  }

  /**
   * Causes this controller's output to mirror the provided leader.
   *
   * <p>Only voltage output is mirrored. Settings changed on the leader do not affect the follower.
   *
   * <p>The motor will spin in the same direction as the leader. This can be changed by passing a
   * true constant after the leader parameter.
   *
   * <p>Following anything other than a CAN SPARK MAX is not officially supported.
   *
   * @param leader The motor controller to follow.
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError follow(final CANSparkMax leader) {
    throwIfClosed();
    return follow(leader, false);
  }

  /**
   * Causes this controller's output to mirror the provided leader.
   *
   * <p>Only voltage output is mirrored. Settings changed on the leader do not affect the follower.
   *
   * <p>Following anything other than a CAN SPARK MAX is not officially supported.
   *
   * @param leader The motor controller to follow.
   * @param invert Set the follower to output opposite of the leader
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError follow(final CANSparkMax leader, boolean invert) {
    throwIfClosed();
    return follow(ExternalFollower.kFollowerSparkMax, leader.getDeviceId(), invert);
  }

  /**
   * Causes this controller's output to mirror the provided leader.
   *
   * <p>Only voltage output is mirrored. Settings changed on the leader do not affect the follower.
   *
   * <p>The motor will spin in the same direction as the leader. This can be changed by passing a
   * true constant after the deviceID parameter.
   *
   * <p>Following anything other than a CAN SPARK MAX is not officially supported.
   *
   * @param leader The type of motor controller to follow (Talon SRX, SPARK MAX, etc.).
   * @param deviceID The CAN ID of the device to follow.
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError follow(ExternalFollower leader, int deviceID) {
    throwIfClosed();
    boolean inverted = CANSparkMaxJNI.c_SparkMax_GetInverted(sparkMaxHandle);
    return follow(leader, deviceID, inverted);
  }

  /**
   * Causes this controller's output to mirror the provided leader.
   *
   * <p>Only voltage output is mirrored. Settings changed on the leader do not affect the follower.
   *
   * <p>Following anything other than a CAN SPARK MAX is not officially supported.
   *
   * @param leader The type of motor controller to follow (Talon SRX, SPARK MAX, etc.).
   * @param deviceID The CAN ID of the device to follow.
   * @param invert Set the follower to output opposite of the leader
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError follow(ExternalFollower leader, int deviceID, boolean invert) {
    throwIfClosed();
    FollowConfig maxFollower = new FollowConfig();
    maxFollower.leaderArbId = (leader.arbId == 0 ? 0 : leader.arbId | deviceID);
    maxFollower.config.predefined = leader.configId;
    maxFollower.config.invert = invert ? 1 : 0;
    return setFollow(maxFollower);
  }

  /**
   * Returns whether the controller is following another controller
   *
   * @return True if this device is following another controller false otherwise
   */
  public boolean isFollower() {
    throwIfClosed();
    return CANSparkMaxJNI.c_SparkMax_IsFollower(sparkMaxHandle);
  }

  /** @return All fault bits as a short */
  public short getFaults() {
    throwIfClosed();
    return (short) CANSparkMaxJNI.c_SparkMax_GetFaults(sparkMaxHandle);
  }

  /** @return All sticky fault bits as a short */
  public short getStickyFaults() {
    throwIfClosed();
    return (short) CANSparkMaxJNI.c_SparkMax_GetStickyFaults(sparkMaxHandle);
  }

  /**
   * Get the value of a specific fault
   *
   * @param faultID The ID of the fault to retrive
   * @return True if the fault with the given ID occurred.
   */
  public boolean getFault(FaultID faultID) {
    throwIfClosed();
    return CANSparkMaxJNI.c_SparkMax_GetFault(sparkMaxHandle, faultID.value);
  }

  /**
   * Get the value of a specific sticky fault
   *
   * @param faultID The ID of the sticky fault to retrive
   * @return True if the sticky fault with the given ID occurred.
   */
  public boolean getStickyFault(FaultID faultID) {
    throwIfClosed();
    return CANSparkMaxJNI.c_SparkMax_GetStickyFault(sparkMaxHandle, faultID.value);
  }

  /** @return The voltage fed into the motor controller. */
  public double getBusVoltage() {
    throwIfClosed();
    return (double) CANSparkMaxJNI.c_SparkMax_GetBusVoltage(sparkMaxHandle);
  }

  /** @return The motor controller's applied output duty cycle. */
  public double getAppliedOutput() {
    throwIfClosed();
    return (double) CANSparkMaxJNI.c_SparkMax_GetAppliedOutput(sparkMaxHandle);
  }

  /** @return The motor controller's output current in Amps. */
  public double getOutputCurrent() {
    throwIfClosed();
    return (double) CANSparkMaxJNI.c_SparkMax_GetOutputCurrent(sparkMaxHandle);
  }

  /** @return The motor temperature in Celsius. */
  public double getMotorTemperature() {
    throwIfClosed();
    return (double) CANSparkMaxJNI.c_SparkMax_GetMotorTemperature(sparkMaxHandle);
  }

  /**
   * Clears all sticky faults.
   *
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError clearFaults() {
    throwIfClosed();
    return REVLibError.fromInt(CANSparkMaxJNI.c_SparkMax_ClearFaults(sparkMaxHandle));
  }

  /**
   * Writes all settings to flash.
   *
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError burnFlash() {
    throwIfClosed();
    return REVLibError.fromInt(CANSparkMaxJNI.c_SparkMax_BurnFlash(sparkMaxHandle));
  }

  /**
   * Sets timeout for sending CAN messages with SetParameter* and GetParameter* calls. These calls
   * will block for up to this amoutn of time before returning a timeout erro. A timeout of 0 will
   * make the SetParameter* calls non-blocking, and instead will check the response in a separate
   * thread. With this configuration, any error messages will appear on the drivestration but will
   * not be returned by the GetLastError() call.
   *
   * @param milliseconds The timeout in milliseconds.
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError setCANTimeout(int milliseconds) {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_SetCANTimeout(sparkMaxHandle, milliseconds));
  }

  /**
   * Enable soft limits
   *
   * @param direction the direction of motion to restrict
   * @param enable set true to enable soft limits
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError enableSoftLimit(SoftLimitDirection direction, boolean enable) {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_EnableSoftLimit(sparkMaxHandle, direction.value, enable));
  }

  /**
   * Set the soft limit based on position. The default unit is rotations, but will match the unit
   * scaling set by the user.
   *
   * <p>Note that this value is not scaled internally so care must be taken to make sure these units
   * match the desired conversion
   *
   * @param direction the direction of motion to restrict
   * @param limit position soft limit of the controller
   * @return {@link REVLibError#kOk} if successful
   */
  public REVLibError setSoftLimit(SoftLimitDirection direction, float limit) {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_SetSoftLimit(sparkMaxHandle, direction.value, limit));
  }

  /**
   * Get the soft limit setting in the controller
   *
   * @param direction the direction of motion to restrict
   * @return position soft limit setting of the controller
   */
  public double getSoftLimit(SoftLimitDirection direction) {
    throwIfClosed();
    return (double) CANSparkMaxJNI.c_SparkMax_GetSoftLimit(sparkMaxHandle, direction.value);
  }

  /**
   * @param direction The direction of the motion to restrict
   * @return true if the soft limit is enabled.
   */
  public boolean isSoftLimitEnabled(SoftLimitDirection direction) {
    throwIfClosed();
    return (boolean) CANSparkMaxJNI.c_SparkMax_IsSoftLimitEnabled(sparkMaxHandle, direction.value);
  }

  /**
   * Gets the feedback device ID that was set on SparkMax itself.
   *
   * @return Feedback device ID on the SparkMax
   */
  protected int getFeedbackDeviceID() {
    throwIfClosed();
    return (int) CANSparkMaxJNI.c_SparkMax_GetFeedbackDeviceID(sparkMaxHandle);
  }

  /**
   * All device errors are tracked on a per thread basis for all devices in that thread. This is
   * meant to be called immediately following another call that has the possibility of returning an
   * error to validate if an error has occurred.
   *
   * @return the last error that was generated.
   */
  public REVLibError getLastError() {
    throwIfClosed();
    return REVLibError.fromInt(CANSparkMaxJNI.c_SparkMax_GetLastError(sparkMaxHandle));
  }

  /**
   * Set the free speed of the motor being simulated.
   *
   * @param freeSpeed the free speed (RPM) of the motor connected to spark max
   * @return {@link REVLibError#kOk} if successful
   */
  REVLibError setSimFreeSpeed(float freeSpeed) {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_SetSimFreeSpeed(sparkMaxHandle, freeSpeed));
  }

  /**
   * Set the stall torque of the motor being simulated.
   *
   * @param stallTorque The stall torque (N m) of the motor connected to sparkmax
   * @return {@link REVLibError#kOk} if successful
   */
  REVLibError setSimStallTorque(float stallTorque) {
    throwIfClosed();
    return REVLibError.fromInt(
        CANSparkMaxJNI.c_SparkMax_SetSimStallTorque(sparkMaxHandle, stallTorque));
  }

  // package-private
  enum DataPortConfig {
    kNone(-1, "none"),
    kLimitSwitches(0, "limit switches"),
    kAltEncoder(1, "alternate encoder");

    final int m_value;
    final String m_name;

    DataPortConfig(int value, String name) {
      m_value = value;
      m_name = name;
    }

    public static DataPortConfig fromInt(int id) {
      for (DataPortConfig type : values()) {
        if (type.m_value == id) {
          return type;
        }
      }
      return kNone;
    }
  }
}