include "cj_types.j"

library_once ctor {
    module ctor {
        private static integer max = 0;
        private static boolean array empty;

        static thistype create() {
            thistype this = 0;
            loop {
                if this >= max {
                    max++;
                    this.ctor_new();
                    break;
                }
                exitwhen empty[this];
                this++;
            }
            empty[this] = false;
            return this;
        }

        nothing destroy() {
            empty[this] = true;
        }
    }
}

struct UnitEffect extends array {
    private static int max = 0;
    private static bool array empty;
    unit u;
    effect e;
    group g;

    static thistype find(handle h) {
        thistype this = 0;
        whilenot this >= max {
            if h == this.u {
                return this;
            }
            this++;
        }
        return -1;
    }

    static thistype create() {
        thistype this = 0;
        loop {
            if this >= max {
                max++;
                break;
            }
            exitwhen empty[this];
            this++;
        }
        empty[this] = false;
        return this;
    }

    void destroy() {
        this.u = null;
        empty[this] = true;
    }
};

struct Shock extends array {
    private static group G;
    private group g;
    private timer t;

    private void ctor_new() {
        .t = CreateTimer();
    }

    implement ctor;

    static void Start(group g, real time) {
        thistype this = create();
        this.g = g;
        G = g;
        ForGroup(g, \
            lambda void() {
                UnitEffect ue = UnitEffect.find(GetEnumUnit());
                if ue == -1 {
                    ue = UnitEffect.create();
                    ue.u = GetEnumUnit();
                    ue.e = AddSpecialEffectTarget(SHOCK_EFFECT, ue.u, "overhead");
                    UnitAddAbility(ue.u, SHOCK_A);
                    PauseUnit(ue.u, true);
                } else {
                    GroupRemoveUnit(ue.g, ue.u);
                    ue.g = G;
                }
            }
        );
        TimerStart(this.t, time, false, \
            lambda void() {
                handle h = GetExpiredTimer();
                thistype this = 0;
                whilenot h == this.t { this++; }
                loop {
                    unit u = FirstOfGroup(this.g);
                    exitwhen u == null;
                    GroupRemoveUnit(this.g, u);
                    UnitEffect ue = UnitEffect.find(u);
                    DestroyEffect(ue.e);
                    UnitRemoveAbility(ue.u, SHOCK_A);
                    ue.destroy();
                    PauseUnit(u, false);
                }
                DestroyGroup(this.g);
                this.destroy();
                flush locals;
            }
        );
    }
};