how things go, inputly

/// <summary>
/// Used to map an axis from one device to a remapped device
/// </summary>
public record struct AxisMapping(IAxisDevice SourceDevice, int SourceAxisIndex);

/// <summary>
/// Used to map an axis group from one device to a remapped device
/// </summary>>
public record struct AxisGroupMapping(IAxisDevice SourceDevice, int SourceGroupIndex);

/// <summary>
/// Used to map an axis from one device to a remapped device
/// </summary>
public record struct AxisMapping(IAxisDevice SourceDevice, int SourceAxisIndex);

/// <summary>
/// Used to map an axis group from one device to a remapped device
/// </summary>>
public record struct AxisGroupMapping(IAxisDevice SourceDevice, int SourceGroupIndex);

/// <summary>
/// An interface/base class for constructing virtual devices from existing devices
/// The lowest level of virtual device composability / the root layer of input remapping and input accessibility.
/// It is not terribly useful by itself.
/// 
/// Should be paired with other interfaces on a higher level, e.g. IGamepad, IKeyboard, IPointerDevice, etc,
/// and should be supplemented by actual implementations or higher level "Virtual Device" interfaces that make
/// this process more user-friendly
///
/// This is an abstract class so as to facilitate the creation of default implementations of this. The more think about it though,
/// the more torn I feel between making this an interface or a full non-abstract base class
/// </summary>
public abstract class VirtualDevice : IAxisDevice /*, IAxisInputHandler */
{
    /// <summary>
    /// The axes that are mapped to this virtual device.
    /// This list must be identical in length to the number of axes in this virtual device.
    /// If an axis is not mapped, that list element must be null.
    /// </summary>
    public abstract IReadOnlyList<AxisMapping?> AxisMappings { get; }
    
    /// <summary>
    /// The axis groups that are mapped to this virtual device.
    /// This list must be identical in length to the number of axis groups in this virtual device.
    /// 
    /// If an axis group is not mapped externally, that list element must be null, even if all axes are individually mapped in the group.
    /// OR
    /// If an axis group is not mapped externally, but all of its axes are individually mapped, the AxisGroupMapping would be defined as (this, groupIndex).
    /// 
    /// Not sure which is a better approach.
    /// </summary>
    public abstract IReadOnlyList<AxisGroupMapping?> AxisGroupMappings { get; }
    

/// <summary>
/// An interface/base class for constructing virtual devices from existing devices
/// The lowest level of virtual device composability / the root layer of input remapping and input accessibility.
/// It is not terribly useful by itself.
/// 
/// Should be paired with other interfaces on a higher level, e.g. IGamepad, IKeyboard, IPointerDevice, etc,
/// and should be supplemented by actual implementations or higher level "Virtual Device" interfaces that make
/// this process more user-friendly
///
/// This is an abstract class so as to facilitate the creation of default implementations of this. The more think about it though,
/// the more torn I feel between making this an interface or a full non-abstract base class
/// </summary>
public abstract class VirtualDevice : IAxisDevice /*, IAxisInputHandler */
{
    /// <summary>
    /// The axes that are mapped to this virtual device.
    /// This list must be identical in length to the number of axes in this virtual device.
    /// If an axis is not mapped, that list element must be null.
    /// </summary>
    public abstract IReadOnlyList<AxisMapping?> AxisMappings { get; }
    
    /// <summary>
    /// The axis groups that are mapped to this virtual device.
    /// This list must be identical in length to the number of axis groups in this virtual device.
    /// 
    /// If an axis group is not mapped externally, that list element must be null, even if all axes are individually mapped in the group.
    /// OR
    /// If an axis group is not mapped externally, but all of its axes are individually mapped, the AxisGroupMapping would be defined as (this, groupIndex).
    /// 
    /// Not sure which is a better approach.
    /// </summary>
    public abstract IReadOnlyList<AxisGroupMapping?> AxisGroupMappings { get; }
    

    /// <summary>
    /// Applies an axis group from the source device to this virtual device.
    /// Populates the relevant axis mappings as well.
    /// </summary>
    public void SetAxisGroup(IAxisDevice sourceDevice, int sourceGroupIndex, int targetGroupIndex);

    /// <summary>
    /// Applies the specified axis from the source device to this virtual device
    /// </summary>
    public void SetAxis(IAxisDevice sourceDevice, int sourceAxisIndex, int targetAxisIndex);

    /// <summary>
    /// Clears the specified axis from this virtual device. Basicaly, <see cref="AxisMappings"/>[axisIndex] = null
    /// </summary>
    public void ClearAxis(int axisIndex);
    
    /// <summary>
    /// Clears the specified axis group from this virtual device. Basically, <see cref="AxisGroupMappings"/>[groupIndex] = null
    /// Will also clear the individual axis mappings for the axes in the group if clearAxes is true
    /// </summary>
    /// <param name="groupIndex">The index of the axis group</param>
    /// <param name="clearAxes">Whether the axis mappings for the axes in the group should also be cleared</param>
    public void ClearAxisGroup(int groupIndex, bool clearAxes);

    public bool HasAxis(int axisIndex) => AxisMappings[axisIndex] != null;
    
    /// <summary>
    /// Returns true if the device is fully mapped, with all required axes defined
    /// </summary>
    public virtual bool IsFullyMapped => AxisMappings.All(mapping => mapping != null);
    
    /// <summary>
    /// True if they are, false if 1 or more underlying devices have disconnected
    /// </summary>
    public bool AllPhysicalDevicesConnected { get; }

    /// <summary>
    /// True if the axis is mapped and the underlying device is connected
    /// </summary>
    public bool IsAxisAvailable(int axisIndex);

    /// <summary>
    /// Of course it is a virtual device
    /// </summary>
    bool IAxisDevice.IsVirtual => true;
    
    /// <summary>
    /// If true, calling <see cref="SetAxis"/> will set the desired axis, and if the input axis is already mapped to
    /// another virtual axis, that other virtual axis must be cleared.
    /// In other words, forces a 1:1 mapping of input axes to virtual axes.
    /// </summary>
    public bool ForceUniqueInputAxes { get; set; }

    /// <summary>
    /// Replaces all the used axes of the specified device with the matching axes of the new device
    /// </summary>
    /// <throws>InvalidOperationException if the devices are not the same type and no valid axis mappings are provided
    /// to reconcile this. This compatibility is implementation-specific</throws>
    public abstract void ReplaceDevice<T>(T oldDevice, T newDevice, IReadOnlyList<(int, int)>? axisMappings = null) where T : IAxisDevice;
}

    /// <summary>
    /// Applies an axis group from the source device to this virtual device.
    /// Populates the relevant axis mappings as well.
    /// </summary>
    public void SetAxisGroup(IAxisDevice sourceDevice, int sourceGroupIndex, int targetGroupIndex);

    /// <summary>
    /// Applies the specified axis from the source device to this virtual device
    /// </summary>
    public void SetAxis(IAxisDevice sourceDevice, int sourceAxisIndex, int targetAxisIndex);

    /// <summary>
    /// Clears the specified axis from this virtual device. Basicaly, <see cref="AxisMappings"/>[axisIndex] = null
    /// </summary>
    public void ClearAxis(int axisIndex);
    
    /// <summary>
    /// Clears the specified axis group from this virtual device. Basically, <see cref="AxisGroupMappings"/>[groupIndex] = null
    /// Will also clear the individual axis mappings for the axes in the group if clearAxes is true
    /// </summary>
    /// <param name="groupIndex">The index of the axis group</param>
    /// <param name="clearAxes">Whether the axis mappings for the axes in the group should also be cleared</param>
    public void ClearAxisGroup(int groupIndex, bool clearAxes);

    public bool HasAxis(int axisIndex) => AxisMappings[axisIndex] != null;
    
    /// <summary>
    /// Returns true if the device is fully mapped, with all required axes defined
    /// </summary>
    public virtual bool IsFullyMapped => AxisMappings.All(mapping => mapping != null);
    
    /// <summary>
    /// True if they are, false if 1 or more underlying devices have disconnected
    /// </summary>
    public bool AllPhysicalDevicesConnected { get; }

    /// <summary>
    /// True if the axis is mapped and the underlying device is connected
    /// </summary>
    public bool IsAxisAvailable(int axisIndex);

    /// <summary>
    /// Of course it is a virtual device
    /// </summary>
    bool IAxisDevice.IsVirtual => true;
    
    /// <summary>
    /// If true, calling <see cref="SetAxis"/> will set the desired axis, and if the input axis is already mapped to
    /// another virtual axis, that other virtual axis must be cleared.
    /// In other words, forces a 1:1 mapping of input axes to virtual axes.
    /// </summary>
    public bool ForceUniqueInputAxes { get; set; }

    /// <summary>
    /// Replaces all the used axes of the specified device with the matching axes of the new device
    /// </summary>
    /// <throws>InvalidOperationException if the devices are not the same type and no valid axis mappings are provided
    /// to reconcile this. This compatibility is implementation-specific</throws>
    public abstract void ReplaceDevice<T>(T oldDevice, T newDevice, IReadOnlyList<(int, int)>? axisMappings = null) where T : IAxisDevice;
}