#define MF3

using System;
using System.Collections;
using System.Windows.Input;
using Microsoft.SPOT;
using Microsoft.SPOT.Input;
using Microsoft.SPOT.Presentation;
using Microsoft.SPOT.Hardware;
using UAM.InformatiX.SPOT.Hardware;

namespace UAM.InformatiX.SPOT.Input
{
public sealed class MatrixKeyboardInputProvider
{
private class ModifierTuplet
{
public MatrixKeyboard.KeyLocation Location;
public ModifierKeys Modifier;
public ModifierBehavior Behavior;
}
private class ButtonTuplet
{
public MatrixKeyboard.KeyLocation Location;
public ModifierKeys Modifier;
public Button Button;
}

public readonly Dispatcher Dispatcher;

private MatrixKeyboard _keyboard;
private ReportInputCallback _reportCallback;
private RaiseEventCallback _eventCallback;
private InputProviderSite _site;
private PresentationSource _source;

public MatrixKeyboardInputProvider(MatrixKeyboard keyboard, PresentationSource source)
{
_source = source;
_keyboard = keyboard;
_site = InputManager.CurrentInputManager.RegisterInputProvider(this);
_reportCallback = new ReportInputCallback(_site.ReportInput);
_eventCallback = new RaiseEventCallback(RaiseEvent);
Dispatcher = Dispatcher.CurrentDispatcher;

_keyboard.KeyPressed += new MatrixKeyboard.KeyEventHandler(KeyPressed);
_keyboard.KeyReleased += new MatrixKeyboard.KeyEventHandler(KeyReleased);
}

private ArrayList _currentModifiers = new ArrayList();
private ModifierKeys _currentModifier = ModifierKeys.None;
public ModifierKeys CurrentModifier { get { return _currentModifier; } }

private ModifierKeys GetCurrentModifier()
{
ModifierKeys modifier = ModifierKeys.None;
for (int i = 0; i < _currentModifiers.Count; i++)
modifier |= ((ModifierTuplet)_currentModifiers[i]).Modifier;

return modifier;
}
private void RemoveTemporaryModifiers()
{
ModifierKeys modifier = ModifierKeys.None;
for (int i = _currentModifiers.Count - 1; i >= 0; i--)
{
ModifierTuplet t = (ModifierTuplet)_currentModifiers[i];
switch (t.Behavior)
{
case ModifierBehavior.StickyKey:
_currentModifiers.RemoveAt(i);
break;
case ModifierBehavior.ToggleKey:
case ModifierBehavior.Normal:
default:
modifier |= t.Modifier;
break;
}
}

if (_currentModifier != modifier)
{
_currentModifier = modifier;
OnCurrentModifierChanged();
}
}
private void AddCurrentModifier(ModifierTuplet tuplet)
{
_currentModifiers.Add(tuplet);

ModifierKeys newModifier = _currentModifier | tuplet.Modifier;
if (newModifier != _currentModifier)
{
_currentModifier = newModifier;
OnCurrentModifierChanged();
}
}
private void RemoveCurrentModifierAt(int index)
{
_currentModifiers.RemoveAt(index);

ModifierKeys newModifier = GetCurrentModifier();
if (newModifier != _currentModifier)
{
_currentModifier = newModifier;
OnCurrentModifierChanged();
}
}

private void KeyReleased(MatrixKeyboard keyboard, MatrixKeyboard.KeyLocation location, TimeSpan time)
{
ButtonTuplet b = GetButton(location, _currentModifier);
if (b != null)
{
ReportButton(b.Button, time, false);
RemoveTemporaryModifiers();
}
}
private void KeyPressed(MatrixKeyboard keyboard, MatrixKeyboard.KeyLocation location, TimeSpan time)
{
ModifierTuplet m = GetModifier(location);
if (m != null)
{
switch (m.Behavior)
{
case ModifierBehavior.Normal:
AddCurrentModifier(m);
break;
case ModifierBehavior.StickyKey:
case ModifierBehavior.ToggleKey:
int index = _currentModifiers.IndexOf(m);
if (index < 0)
AddCurrentModifier(m);
else
RemoveCurrentModifierAt(index);
break;
default:
throw new NotSupportedException("Unknown ModifierBehavior value.");
}
}

ButtonTuplet b = GetButton(location, _currentModifier);
if (b != null)
ReportButton(b.Button, time, true);
}

private delegate bool ReportInputCallback(InputReport inputReport);
private delegate void RaiseEventCallback(RoutedEventArgs args);
private void ReportButton(Button button, TimeSpan time, bool state)
{
RawButtonActions action = state ? RawButtonActions.ButtonDown : RawButtonActions.ButtonUp;
RawButtonInputReport report = new RawButtonInputReport(_source, time, button, action);

#if MF3
Dispatcher.BeginInvoke(_reportCallback, report);
#else
if (button > Button.None && button <= Button.Last)
Dispatcher.BeginInvoke(_reportCallback, report);
else
{
RoutedEventArgs args = new UncheckedButtonEventArgs(null, time, button);
args.RoutedEvent = state ? Buttons.ButtonDownEvent : Buttons.ButtonUpEvent;
Dispatcher.BeginInvoke(_eventCallback, args);
}
#endif
}
private void RaiseEvent(RoutedEventArgs args)
{
UIElement target = Buttons.FocusedElement;
if (target != null)
target.RaiseEvent(args);
}

private ModifierTuplet[] _registeredModifiers = new ModifierTuplet[0];
private ModifierTuplet GetModifier(MatrixKeyboard.KeyLocation location)
{
for (int i = 0; i < _registeredModifiers.Length; i++)
if (_registeredModifiers[i].Location == location) return _registeredModifiers[i];

return null;
}
public void RegisterModifier(MatrixKeyboard.KeyLocation[] locations, ModifierKeys[] modifiers, ModifierBehavior[] behaviors)
{
if (locations == null) throw new ArgumentNullException("locations");
if (modifiers == null) throw new ArgumentNullException("modifiers");
if (behaviors == null) behaviors = new ModifierBehavior[locations.Length];

if (locations.Length != modifiers.Length || locations.Length != behaviors.Length) throw new ArgumentException("All arrays must be of the same length.");

ModifierTuplet[] tuplets = new ModifierTuplet[locations.Length];
for (int i = 0; i < locations.Length; i++)
{
if (modifiers[i] == ModifierKeys.None) throw new ArgumentException("'ModifierKeys.None' is not a valid modifier for registration.", "modifiers");
if (GetModifier(locations[i]) != null) throw new ArgumentException(locations[i] + " is already registered as a modifier.", "keys");

tuplets[i] = new ModifierTuplet();
tuplets[i].Location = locations[i];
tuplets[i].Behavior = behaviors[i];
tuplets[i].Modifier = modifiers[i];
}

int length = _registeredModifiers.Length;
ModifierTuplet[] newArrayT = new ModifierTuplet[length + tuplets.Length];

_registeredModifiers.CopyTo(newArrayT, 0);
tuplets.CopyTo(newArrayT, length);

lock (_registeredModifiers)
_registeredModifiers = newArrayT;
}
public void RegisterModifier(MatrixKeyboard.KeyLocation location, ModifierKeys modifier, ModifierBehavior behavior)
{
RegisterModifier(new MatrixKeyboard.KeyLocation[] { location }, new ModifierKeys[] { modifier }, new ModifierBehavior[] { behavior });
}

private ButtonTuplet[] _registeredButtons = new ButtonTuplet[0];
private ButtonTuplet GetButton(MatrixKeyboard.KeyLocation location, ModifierKeys modifier)
{
for (int i = 0; i < _registeredButtons.Length; i++)
if (_registeredButtons[i].Location == location && _registeredButtons[i].Modifier == modifier) return _registeredButtons[i];

return null;
}
public void RegisterButton(MatrixKeyboard.KeyLocation[] locations, ModifierKeys[] modifiers, Button[] buttons)
{
if (locations == null) throw new ArgumentNullException("locations");
if (modifiers == null) modifiers = new ModifierKeys[locations.Length];
if (buttons == null) throw new ArgumentNullException("buttons");

if (locations.Length != modifiers.Length || locations.Length != buttons.Length) throw new ArgumentException("All arrays must be of the same length.");

ButtonTuplet[] tuplets = new ButtonTuplet[locations.Length];
for (int i = 0; i < locations.Length; i++)
{
if (buttons[i] == Button.None) throw new ArgumentException("'Button.None' is not a valid button for registration.", "buttons");
if (GetButton(locations[i], modifiers[i]) != null) throw new ArgumentException(locations[i] + " with supplied modifier is already registered as a button.", "buttons");

tuplets[i] = new ButtonTuplet();
tuplets[i].Location = locations[i];
tuplets[i].Modifier = modifiers[i];
tuplets[i].Button = buttons[i];
}

int length = _registeredButtons.Length;
ButtonTuplet[] newArrayT = new ButtonTuplet[length + tuplets.Length];

_registeredButtons.CopyTo(newArrayT, 0);
tuplets.CopyTo(newArrayT, length);

lock (_registeredButtons)
_registeredButtons = newArrayT;
}
public void RegisterButton(MatrixKeyboard.KeyLocation location, ModifierKeys modifier, Button button)
{
RegisterButton(new MatrixKeyboard.KeyLocation[] { location }, new ModifierKeys[] { modifier }, new Button[] { button });
}
public void RegisterButton(MatrixKeyboard.KeyLocation[] locations, ModifierKeys modifier, Button[] buttons)
{
if (locations == null) throw new ArgumentNullException("locations");

ModifierKeys[] modifiers = new ModifierKeys[locations.Length];
if (modifier != ModifierKeys.None)
for (int i = 0; i < modifiers.Length; i++)
modifiers[i] = modifier;

RegisterButton(locations, modifiers, buttons);
}

private void OnCurrentModifierChanged()
{
if (CurrentModifierChanged != null)
CurrentModifierChanged(this, EventArgs.Empty);
}
public event EventHandler CurrentModifierChanged;
}
}