module tk.types;

private import std.string;
private import std.typecons;
private import std.algorithm;

      /*
enum ButtonPress {
    SINGLE,
    DOUBLE,
    TRIPLE,
    RELEASE
}

string toString(in ButtonPress bp) {
    switch (bp) {
    case ButtonPress.SINGLE:  return "SINGLE";
    case ButtonPress.DOUBLE:  return "DOUBLE";
    case ButtonPress.TRIPLE:  return "TRIPLE";
    case ButtonPress.RELEASE: return "RELEASE";
    default:                  return std.string.format("<UNKNOWN ButtonPress: %s>", bp);
    }
}

enum ButtonNumber {
    BUTTON_1,
    BUTTON_2,
    BUTTON_3,
    BUTTON_4,
    BUTTON_5,
}

string toString(in ButtonNumber bn) {
    switch (bn) {
    case ButtonNumber.BUTTON_1: return "BUTTON_1";
    case ButtonNumber.BUTTON_2: return "BUTTON_2";
    case ButtonNumber.BUTTON_3: return "BUTTON_3";
    case ButtonNumber.BUTTON_4: return "BUTTON_4";
    case ButtonNumber.BUTTON_5: return "BUTTON_5";
    default:                    return std.string.format("<UNKNOWN ButtonNumber: %s>", bn);
    }
}

enum ScrollDirection {
    UP,
    DOWN,
    LEFT,
    RIGHT
}

string toString(in ScrollDirection sd) {
    switch (sd) {
    case ScrollDirection.UP:    return "UP";
    case ScrollDirection.DOWN:  return "DOWN";
    case ScrollDirection.LEFT:  return "LEFT";
    case ScrollDirection.RIGHT: return "RIGHT";
    default:                    return std.string.format("<UNKNOWN ScrollDirection: %s>", sd);
    }
}

enum Modifier {
    SHIFT,
    CAPS_LOCK,
    CONTROL,
    ALT,
    NUM_LOCK,
    META,
    SCROLL_LOCK,
    BUTTON_1,
    BUTTON_2,
    BUTTON_3,
    BUTTON_4,
    BUTTON_5
}

string toString(in Modifier m) {
    switch (m) {
    case Modifier.SHIFT:       return "SHIFT";
    case Modifier.CAPS_LOCK:   return "CAPS_LOCK";
    case Modifier.CONTROL:     return "CONTROL";
    case Modifier.ALT:         return "ALT";
    case Modifier.NUM_LOCK:    return "NUM_LOCK";
    case Modifier.META:        return "META";
    case Modifier.SCROLL_LOCK: return "SCROLL_LOCK";
    case Modifier.BUTTON_1:    return "BUTTON_1";
    case Modifier.BUTTON_2:    return "BUTTON_2";
    case Modifier.BUTTON_3:    return "BUTTON_3";
    case Modifier.BUTTON_4:    return "BUTTON_4";
    case Modifier.BUTTON_5:    return "BUTTON_5";
    default:                   return std.string.format("<UNKNOWN Modifier: %s>", m);
    }
}
*/

mixin(defineEnum!("ButtonPress",
                  "SINGLE", "DOUBLE", "TRIPLE", "RELEASE"));
mixin(defineEnum!("ButtonNumber",
                  "BUTTON_1", "BUTTON_2", "BUTTON_3", "BUTTON_4", "BUTTON_5"));
mixin(defineEnum!("ScrollDirection",
                  "UP", "DOWN", "LEFT", "RIGHT"));
mixin(defineEnum!("Modifier",
                  "SHIFT", "CAPS_LOCK", "CONTROL", "ALT", "NUM_LOCK", "META",
                  "SCROLL_LOCK", "BUTTON_1", "BUTTON_2", "BUTTON_3", "BUTTON_4", "BUTTON_5"));

struct Mask2 {
    this(in Modifier[] modifiers) {
        _modifiers = modifiers.dup;
    }

    string toString() const {
        string s;

        foreach (Modifier m; _modifiers) {
            s ~= enumToString(m);
        }

        return s;
    }

    bool is_set(Modifier m) const {
        foreach (Modifier m2; _modifiers) {
            if (m == m2) {
                return true;
            }
        }

        return false;
    }

    bool is_unset(Modifier m) const {
        return !is_set(m);
    }

    private {
        Modifier[] _modifiers;
    }
}

class Mask {
    this() {
    }

    this(in Mask other) {
        mBits = other.mBits;
    }

    void add(Modifier modifier) { mBits |= to_bit(modifier); }
    void remove(Modifier modifier) { mBits &= ~to_bit(modifier); }
    bool query(Modifier modifier) const { return cast(bool)(mBits & to_bit(modifier)); }

    override string toString() const {
        Modifier m = Modifier.SHIFT;
        return enumToString(m);
        /*
        return format("Mask: %s", m);
        */
        //return format("%d", mBits);
    }

    private {
        static int to_bit(Modifier modifier) { return 1 << cast(int)modifier; }
        int mBits;
    }
}