--[[
* Ashita - Copyright (c) 2014 - 2016 atom0s [atom0s@live.com]
*
* This work is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/ or send a letter to
* Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
*
* By using Ashita, you agree to the above license and its terms.
*
*      Attribution - You must give appropriate credit, provide a link to the license and indicate if changes were
*                    made. You must do so in any reasonable manner, but not in any way that suggests the licensor
*                    endorses you or your use.
*
*   Non-Commercial - You may not use the material (Ashita) for commercial purposes.
*
*   No-Derivatives - If you remix, transform, or build upon the material (Ashita), you may not distribute the
*                    modified material. You are, however, allowed to submit the modified works back to the original
*                    Ashita project in attempt to have it added to the original project.
*
* You may not apply legal terms or technological measures that legally restrict others
* from doing anything the license permits.
*
* No warranties are given.
]]--

----------------------------------------------------------------------------------------------------
-- Variables
----------------------------------------------------------------------------------------------------
local bluemage          = {};   -- The overall table this library uses.
bluemage.queue          = {};   -- The queue to handle events this library does.
bluemage.delay          = 0.65; -- The delay to prevent spamming packets.
bluemage.timer          = 0;    -- The current time used for delaying packets.
bluemage.mem            = {};   -- The table holding memory specific data.
bluemage.mem.offset1    = 0;    -- The value for the current set blue spells.
bluemage.mem.offset2    = 0;    -- The memory location for the current blue magic point info.

----------------------------------------------------------------------------------------------------
-- func: msg
-- desc: Prints out a message with the addon tag at the front.
----------------------------------------------------------------------------------------------------
function msg(s)
    local txt = '\31\200[\31\05' .. _addon.name .. '\31\200]\31\130 ' .. s;
    print(txt);
end

----------------------------------------------------------------------------------------------------
-- func: err
-- desc: Prints out an error message with the addon tag at the front.
----------------------------------------------------------------------------------------------------
function err(s)
    local txt = '\31\200[\31\05' .. _addon.name .. '\31\200]\31\39 ' .. s;
    print(txt);
end

----------------------------------------------------------------------------------------------------
-- func: initialize
-- desc: Prepares this library for usage.
----------------------------------------------------------------------------------------------------
function bluemage.initialize()
    -- Locate the pointers needed for this library..
    local pointer1 = ashita.memory.findpattern('FFXiMain.dll', 0, 'C1E1032BC8B0018D????????????B9????????F3A55F5E5B', 10, 0);
    local pointer2 = ashita.memory.findpattern('FFXiMain.dll', 0, 'A1????????33C98A4E5E33D28A565D5F5E8950148948185B83C414C20400', 1, 0);

    -- Ensure the patterns were found..
    if (pointer1 == 0 or pointer2 == 0) then
        err('Failed to locate required pattern(s).');
        return false;
    end
    
    -- Read the first pointers value..
    local offset1 = ashita.memory.read_uint32(pointer1);
    if (offset1 == 0) then
        err('Failed to read required pointer value. (1)');
        return false;
    end
    
    -- Read the first pointers value..
    local offset2 = ashita.memory.read_uint32(pointer2);
    if (offset2 == 0) then
        err('Failed to read required pointer value. (2)');
        return false;
    end

    -- Store the values..
    bluemage.mem.offset1 = offset1;
    bluemage.mem.offset2 = offset2;
end

----------------------------------------------------------------------------------------------------
-- func: is_blue_main
-- desc: Determines if the players main job is blue mage.
----------------------------------------------------------------------------------------------------
function bluemage.is_blue_main()
    return (AshitaCore:GetDataManager():GetPlayer():GetMainJob() == 16);
end

----------------------------------------------------------------------------------------------------
-- func: is_blue_sub
-- desc: Determines if the players sub job is blue mage.
----------------------------------------------------------------------------------------------------
function bluemage.is_blue_sub()
    return (AshitaCore:GetDataManager():GetPlayer():GetSubJob() == 16);
end

----------------------------------------------------------------------------------------------------
-- func: get_spent_points
-- desc: Obtains the current spent blue magic points.
----------------------------------------------------------------------------------------------------
function bluemage.get_spent_points()
    -- Determine if the blue points offset is valid..
    if (bluemage.mem.offset2 == 0) then
        err('Cannot read blue spell points; pointer is invalid.');
        return -1;
    end

    -- Read the pointer..
    local pointer = ashita.memory.read_uint32(bluemage.mem.offset2);
    if (pointer == 0) then
        return -1;
    end

    -- Return the spent count..
    return ashita.memory.read_uint8(pointer + 0x14);
end

----------------------------------------------------------------------------------------------------
-- func: get_max_points
-- desc: Obtains the max available blue magic points.
----------------------------------------------------------------------------------------------------
function bluemage.get_max_points()
    -- Determine if the blue points offset is valid..
    if (bluemage.mem.offset2 == 0) then
        err('Cannot read blue spell points; pointer is invalid.');
        return -1;
    end

    -- Read the pointer..
    local pointer = ashita.memory.read_uint32(bluemage.mem.offset2);
    if (pointer == 0) then
        return -1;
    end

    -- Return the spent count..
    return mem.ashita.memory.read_uint8(pointer + 0x18);
end

----------------------------------------------------------------------------------------------------
-- func: get_spells
-- desc: Obtains the current blue mage spells that are set.
----------------------------------------------------------------------------------------------------
function bluemage.get_spells()
    local spells = {};
    local offset = 0x04;

    -- Determine if the blue spell offset is valid..
    if (bluemage.mem.offset1 == 0) then
        err('Cannot read blue spells; pointer is invalid.');
        return {};
    end

    -- Offset shifts 0xA0 if player is subbed blue..
    if (bluemage.is_blue_sub()) then
        offset = 0xA0;
    end

    -- Read the inventory pointer..    
    local pointer = ashita.memory.read_uint32(AshitaCore:GetPointerManager():GetPointer('inventory'));
    if (pointer == 0) then
        return {};
    end

    -- Read the inventory pointer..
    pointer = ashita.memory.read_uint32(pointer);
    if (pointer == 0) then
        return {};
    end

    -- Read the spell data..
    return ashita.memory.read_array((pointer + bluemage.mem.offset1) + offset, 0x14);
end

----------------------------------------------------------------------------------------------------
-- func: get_spell_names
-- desc: Obtains the current blue mage spells that are set. (Names)
----------------------------------------------------------------------------------------------------
function bluemage.get_spell_names()
    -- Obtain the current spell list..
    local spells = bluemage.get_spells();
    if (spells == nil or #spells == 0) then
        return {};
    end

    -- Loop the spells and obtain their names..
    local names = {};
    for k, v in pairs(spells) do
        -- Obtain only valid set spells..
        if (v ~= 0) then
            -- Obtain the spell..
            local spell = AshitaCore:GetResourceManager():GetSpellById(v + 512);
            if (spell == nil) then
                err(string.format('Failed to obtain spell name for spell id: %d', v + 512));
            else
                table.insert(names, spell.Name[0]);
            end
        end
    end

    return names;
end

----------------------------------------------------------------------------------------------------
-- func: reset_all_spells
-- desc: Resets all current set spells to nothing.
----------------------------------------------------------------------------------------------------
function bluemage.reset_all_spells()
    -- Obtain the current spells..
    local spells = bluemage.get_spells();
    if (spells == nil or #spells == 0) then
        return;
    end

    -- Prepare some packet variables..
    local isSubBlu = 0;
    if (bluemage.is_blue_sub() == 16) then
        isSubBlu = 1;
    end

    -- Build the packet..
    local packet = string.char(0x02, 0x53, 0x00, 0x00) .. string.char(0x00, 0x00, 0x00, 0x00, 0x10, isSubBlu, 0x00, 0x00);
    for x = 1, 20 do
        packet = packet .. string.char(spells[x]);
    end
    packet = packet .. string.rep(string.char(0x00), 0x84);
    packet = packet:totable();

    -- Add the packet to our queue..
    table.insert(bluemage.queue, { 0x102, packet });
end

----------------------------------------------------------------------------------------------------
-- func: set_spell
-- desc: Sets a blue mage spell. (Or removes one if the id is 0.)
----------------------------------------------------------------------------------------------------
function bluemage.set_spell(id, index)
    -- Determine if the blue spell offset is valid..
    if (bluemage.mem.offset1 == 0) then
        err('Cannot set blue spell; pointer is invalid.');
        return false;
    end

    -- Obtain the current spells..
    local spells = bluemage.get_spells();
    if (spells == nil or #spells == 0) then
        return false;
    end

    -- If the id is 0, we want to remove the spell in the given slot..
    if (id == 0) then
        -- Obtain the current spell at the given index..
        local spell = spells[index];
        if (spell == nil or spell == 0) then
            return true;
        end

        -- Prepare some packet variables..
        local isSubBlu = 0;
        if (bluemage.is_blue_sub() == true) then
            isSubBlu = 1;
        end

        -- Build the packet..
        local packet = string.char(0x02, 0x53, 0x00, 0x00) .. string.char(0x00, 0x00, 0x00, 0x00, 0x10, isSubBlu, 0x00, 0x00);
        packet = packet .. string.rep(string.char(0x00), index - 1) .. string.char(spell);
        packet = packet .. string.rep(string.char(0x00), 0x98 - index);
        packet = packet:totable();

        -- Add the packet to our queue..
        table.insert(bluemage.queue, { 0x102, packet });
    else
        -- Calculate the spell id..
        local spell = id - 512;
        if (spell < 0) then
            err(string.format('Cannot set blue spell; invalid spell id given. (%d)', spell));
            return false;
        end

        -- Prepare some packet variables..
        local isSubBlu = 0;
        if (bluemage.is_blue_sub() == true) then
            isSubBlu = 1;
        end

        -- Build the packet..
        local packet = string.char(0x02, 0x53, 0x00, 0x00) .. string.char(spell, 0x00, 0x00, 0x00, 0x10, isSubBlu, 0x00, 0x00);
        packet = packet .. string.rep(string.char(0x00), index - 1) .. string.char(spell);
        packet = packet .. string.rep(string.char(0x00), 0x98 - index);
        packet = packet:totable();

        -- Add the packet to our queue..
        table.insert(bluemage.queue, { 0x102, packet });
    end
end

----------------------------------------------------------------------------------------------------
-- func: set_spell_by_name
-- desc: Sets a blue mage spell by name. (Or removes one if the name is empty.)
----------------------------------------------------------------------------------------------------
function bluemage.set_spell_by_name(name, index)
    -- Remove the spell if the name is null or empty..
    if (name == nil or name == '') then
        return bluemage.set_spell(0, index);
    end

    -- Obtain the spells information by its name..
    local spell = AshitaCore:GetResourceManager():GetSpellByName(name, 0);
    if (spell == nil) then
        err('Failed to obtain spell information for spell: ' .. name);
        return;
    end

    -- Ensure this is a blue mage spell..
    if (spell.Index < 512 or spell.Index > 1024) then
        err('Failed to set spell: ' .. name .. ' - Spell is invalid or not a blue mage spell.');
        return;
    end

    -- Set the spell..
    bluemage.set_spell(spell.Index, index);
end

----------------------------------------------------------------------------------------------------
-- func: process_queue
-- desc: Processes the packet queue to be sent.
----------------------------------------------------------------------------------------------------
function bluemage.process_queue()
    if  (os.clock() >= (bluemage.timer + bluemage.delay)) then
        bluemage.timer = os.clock();

        -- Ensure the queue has something to process..
        if (#bluemage.queue > 0) then
            -- Obtain the first queue entry..
            local data = table.remove(bluemage.queue, 1);

            -- Send the queued object..
            AddOutgoingPacket(data[1], data[2]);
        end
    end
end

----------------------------------------------------------------------------------------------------
-- Returns the blue mage table.
----------------------------------------------------------------------------------------------------
return bluemage;