-- Code edited by TheMartinWheeler (TheShinyTuxedo) on 6/1/2012
-- Code update by Bystander on  8/28/2011
------------------------------------------------------------------------------------------------------------
POLL_DELAY = 25     -- Sleep time after each poll (beware of number below 25)
POLL_FAMILY = "kb"  -- The device polling will take place on.  Prefered to not be on macroed device.
KB_EVENTS = true    -- If you don't have a logitech keyboard, make this false/nil or comment out
-- LHC_EVENTS = true   -- if you don't have a logitech left handed controller, make this false/nil or comment out
------------------------------------------------------------------------------------------------------------

DEVICE = "kb"
color = 1
speed = 25  -- this should alwasy be equal or larger than POLL_DELAY
disco = 0
BLUE = 255
DIRECTION = 1

function _onActivation(event, arg, family)
--
-- ADD ANY START UP ROUTINES HERE
--
--    POLL:setMKeyModifier( "default", "mb5", "mb4", "lhc" )  -- Allows the use of Modifiers to change M pages

    ctDiscoColors = CoThread:new(discoColors)
end

function _OnEvent(event, arg, family)
--
-- ADD EVENT FUNCTIONALITY HERE
--

    if (event == "G_PRESSED" and arg == 1 and GetMKeyState(DEVICE) == 1) then
        if color == 1 then
            color = 2
            ctDiscoColors:stop()    -- stops randomColors if it was running()
            SetBacklightColor(255, 0, 0, DEVICE) -- Red
            OutputLogMessage("RED\n")
        elseif color == 2 then
            color = 3
            SetBacklightColor(0, 0, 255, DEVICE) -- Blue
            OutputLogMessage("BLUE\n")
        elseif color == 3 then
            color = 4
            SetBacklightColor(255, 0, 255, DEVICE) -- Purple
            OutputLogMessage("PURPLE\n")
        elseif color == 4 then
            color = 1
            ctDiscoColors:start()   -- starts discoColors
            OutputLogMessage("DISCO\n")
        end
    end

    if (event == "G_PRESSED" and arg == 3 and disco == 1) then
        speed = speed-25
        if speed < POLL_DELAY   then    -- if speed is 0 or less, the program will not reliquish control
            speed = POLL_DELAY
        end
    end

    if (event == "G_PRESSED" and arg == 6 and disco == 1) then
        speed = speed+25
    end

    ctDiscoColors:run() -- this will run discoColors as long as it hasn't finished or been stopped with :stop()
end

function discoColors(ct)
    while true do
        disco = 1

        if BLUE == 255 and DIRECTION == 0 then
            DIRECTION = 1
        elseif BLUE == 1 and DIRECTION == 1 then
            DIRECTION == 0
        end


        if DIRECTION == 1
            SetBacklightColor(0, 0, BLUE, DEVICE) -- BLUE
            BLUE = BLUE - 1
            ct:sleep(speed)
        elseif DIRECTION == 0
            SetBacklightColor(0, 0, BLUE, DEVICE) -- BLUE
            BLUE = BLUE + 1
            ct:sleep(speed)
        end

        if color ~= 1 then    -- if color == 1 it will continue to loop as before
            disco = 0
            break
        end
    end
end

--------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------
--
--                             NOTHING BELOW HERE NEEDS TO BE ALTERED
--
--------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------
-- function Type(v)  -- returns what type of object v is.  It works with my objects as well
-- function log(...) -- MessageLogOutput(...)
--------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------
-- function CoThread:new(f)      f - function(coThread,...)   coThread is the controlling CoThread
-- function CoThread:recreate()  kill existing coroutine and recreate
-- function CoThread:create()    creates coroutine
-- function CoThread:isDead()    true if coroutine is dead or nil/false
-- function CoThread:run(...)    run coroutine with variables don't include mt
-- function CoThread:kill()      kill coroutine
-- function CoThread:yield()     use in function(coThread,...) to yield
-- function CoThread:sleep(Milliseconds) use in function(coThread,...) to sleep for Milliseconds
-- function CoThread:start()     does the same thing as recreate()
-- function CoThread:stop()      does the same thing as kill()
-- function CoThread:isFinished() same as isDead()
--------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------
-- function Poll:new(family, delay)         delay is sleep time between polls
-- function Poll:run(event, arg, family)    handles events and performs the polling as long as it's running
-- function Poll:setMKeyModifier( m1, m2, m3, family )  Allows the use of Modifiers to change M pages
-- function Poll:start()                    turn on polling
-- function Poll:stop()                     stop polling
--      function Poll:_press()                  NOT TO BE USED
--      function Poll:release()                 NOT TO BE USED
--      function Poll:setMKeyState(MKeyState)   NOT TO BE USED
------------------------------------------------------------------------------------------------------------

function OnEvent(event, arg, family)
-- POLLING INITIATED HERE
    _GetRunningTime = GetRunningTime()
    if event == "PROFILE_ACTIVATED" then
        ClearLog()
        POLL = Poll:new(POLL_FAMILY, POLL_DELAY)
        POLL:start()
        _onActivation(event, arg, family)
    else
-- POLLING ROUTINES BELOW
        POLL:run(event,arg,family)
        _GetRunningTime = GetRunningTime()
        _OnEvent(event, arg, family)  -- Runs myOnEvent to compartmentalize
    end
end

function log(...)
    if ... == nil then
        error("log(...) cannot display nil\n",2)
    end
    OutputLogMessage(...)
end

function Type(v)
    if type(v) == "table" then
        if v.Type ~= nil then
            return v.Type
        elseif v.type ~= nil then
            return v.type
        end
    end
    return type(v)
end

------------------------------------------------------------------------------------------------------------
-- function Poll:new(family, delay)         delay is sleep time between polls
-- function Poll:run(event, arg, family)    handles events and performs the polling as long as it's running
-- function Poll:setMKeyModifier( m1, m2, m3, family )  Allows the use of Modifiers to change M pages
-- function Poll:start()                    turn on polling
-- function Poll:stop()                     stop polling
--      function Poll:_press()                   NOT TO BE USED
--      function Poll:release()                 NOT TO BE USED
--      function Poll:setMKeyState(MKeyState)   NOT TO BE USED
------------------------------------------------------------------------------------------------------------

Poll = {}
Poll.__index = Poll
Poll.__newindex = function(table, key, value)
    for k,v in pairs(table) do
        if k == key then
            rawset(table,key,value) return
        end
    end
    error("'" .. key .. "' is not a member of Poll.", 2)
end

function Poll:new(family, delay)
    local self = {}

    self.delay = delay or 50
    if family ~= "kb" and family ~= "lhc" then
        error("Poll:new() - 'pFamily' must be 'kb' or 'lhc'", 2)
    end
    self.pFamily = family
    self.presses = 0
    self.running = false
    self.runMKeyModifier = false
    self.MKeyModifier = { nil, nil, nil }   -- "default" or Modifiers. i.e. "lshift", "ctrl"
    self.modFamily = ""
    self.Type = "Poll"

    setmetatable(self, Poll)

    return self
end

--------------------------------------------------------------------------------------------
--  Poll:setMKeyModifier( m1, m2, m3, family )
--  Sets what modifiers will change you to the associated M page of the device on family
--  "shift", "ctrl", "alt", "lshift", "lctrl", "lalt"... are all modifiers
--  "default" is the page that will be set when none of the listed modifiers are pressed
--  "" will cause a page to be ignored.
--  I.E. - Poll:setMKeyModifier( "default", "shift", "ctrl", "lhc" )
--  will set the default page to m1, shift will change you to m2, ctrl to m3 on a left hand controler
--------------------------------------------------------------------------------------------
function Poll:setMKeyModifier( m1, m2, m3, family )
    self.runMKeyModifier = true
    self.MKeyModifier[1] = m1
    self.MKeyModifier[2] = m2
    self.MKeyModifier[3] = m3
    if family ~= "kb" and family ~= "lhc" then  error("Poll:setMKeyModifier() family - needs to be 'kb' or 'lhc'",2) end
    self.modFamily = family
end

function Poll:start()
    self.running = true
    self:setMKeyState()
end

function Poll:stop()
    self.running = false
end

function Poll:_press()
    if self.running then
        self.presses = self.presses + 1
    end
end

function Poll:release()
    if self.running then
        self.presses = self.presses - 1
    end
end

function Poll:setMKeyState()
    if self.runMKeyModifier then
        local default = nil
        local i = 1
        local modMKeyState = nil

        for i = 1, 3, 1 do
            if self.MKeyModifier[i] == "default" then
                default = i
            elseif self.MKeyModifier[i] == "" then
                -- do nothing
            elseif string.find(self.MKeyModifier[i],"mb%d") then
                local iMB = tonumber(string.sub(self.MKeyModifier[i],3))
                if IsMouseButtonPressed(iMB) then
                    modMKeyState = i
                end
            elseif IsModifierPressed(self.MKeyModifier[i]) then
                modMKeyState = i
            end
        end
        if modMKeyState == nil then
            modMKeyState = default
        end
        if modMKeyState ~= nil then
            if self.pFamily == self.modFamily then
                SetMKeyState(modMKeyState, self.pFamily)
                return
            elseif GetMKeyState(self.modFamily) ~= modMKeyState then
                SetMKeyState(modMKeyState, self.modFamily)
            end
        end
    end
    SetMKeyState( GetMKeyState(self.pFamily), self.pFamily )
end

function Poll:run(event, arg, family)
    if self.running and self.pFamily == family then
        if event == "M_PRESSED" then
            self:_press()
        elseif event == "M_RELEASED" then
            if self.presses == 1 then
                self:setMKeyState()
                Sleep(self.delay)
            end
            self:release()
        end
    end
end

--------------------------------------------------------------------------------------------------------
-- function CoThread:new(f)      f - function(coThread,...)   coThread is the controlling CoThread
-- function CoThread:recreate()  kill existing coroutine and recreate
-- function CoThread:create()    creates coroutine
-- function CoThread:isDead()    true if coroutine is dead or nil/false
-- function CoThread:run(...)    run coroutine with variables don't include mt
-- function CoThread:kill()      kill coroutine
-- function CoThread:yield()     use in function(coThread,...) to yield
-- function CoThread:sleep(Milliseconds) use in function(coThread,...) to sleep for Milliseconds
-- function CoThread:start()     does the same thing as recreate()
-- function CoThread:stop()      does the same thing as kill()
-- function CoThread:isFinished() same as isDead()
--------------------------------------------------------------------------------------------------------

CoThread = {}
CoThread.__index = CoThread

function CoThread:new(f) -- f - function(MultiThread)
    local self = {}

    if type(f) ~= "function" then
        error("A function is needed",2)
    end
    self.func = f
    self.co = nil
    self.sleepUntilTimeStamp = nil
    self.Type = "CoThread"

    setmetatable(self, CoThread)
    return self
end

function CoThread:recreate()
    self:kill()
    self.co = coroutine.create(self.func)
end

function CoThread:create()
    self.co = coroutine.create(self.func)
end

function CoThread:isDead()
    if self.co == nil then
        return true
    elseif coroutine.status(self.co) == "dead" then
        self.co = nil
        return true
    else
        return false
    end
end

function CoThread:run(...)
    if self:isDead() then
        return
    end
    if self.sleepUntilTimeStamp ~= nil then
        if _GetRunningTime < self.sleepUntilTimeStamp then
            return
        else
            self.sleepUntilTimeStamp = nil
        end
    end
    coroutine.resume(self.co, self, ...)
end

function CoThread:kill()
    self.co = nil       -- lua automatically deallocated
    self.sleepUntilTimeStamp = nil
end

function CoThread:yield()
    coroutine.yield()
end

function CoThread:sleep(Milliseconds)
    self.sleepUntilTimeStamp = _GetRunningTime + Milliseconds

    coroutine.yield()
end

function CoThread:start()
    self:recreate()
end

function CoThread:stop()
    self:kill()
end

function CoThread:isFinished()
    return self:isDead()
end