local bsk=bsk
local _G=_G
local table=table 
local pairs=pairs
local setmetatable=setmetatable
local ipairs=ipairs
local string=string
local sformat=string.format
local strsplit=strsplit
local tostring=tostring
local type=type
local unpack=unpack
local getn=getn
setfenv(1,bsk)

adminList = {}

local function GuildRosterUpdate()
    local guildInfoText = _G.GetGuildInfoText()
    local newAdminList = {}
    for line in guildInfoText:gmatch("[^\r\n]+") do
        local l,r = line:match("(.*):(.*)") -- could use wow strsplit had I known about it before writing this
        l = string.trim(l or "")
        r = string.trim(r or "")
        if l == "BSKADMIN" then -- found a juicy line. may contain multiple, comma or space delimited
            local admins = {strsplit(", ",r)}
            for _,a in pairs(admins) do
                a = string.trim(a or "")
                if a ~= "" then
                    newAdminList[a] = true
                end
            end
        end
    end

    if me == "Breuemama" then -- todo: strictly debugging ...
        newAdminList[me] = true
        newAdminList["Breue"] = true
    end

    if _G.next(adminList) ~= nil then -- had old admins. don't want to spam on initial load
        -- diff new vs old
        for a in pairs(adminList) do
            if not newAdminList[a] then
                print("Admin removed:", a)
            end
        end
        for a in pairs(newAdminList) do
            if not adminList[a] then
                print("Admin added:",a)
            end
        end
    end
    adminList = newAdminList

    if adminList[me] then -- I'm an admin!
        admin = true
        bsk.db.profile.admin = true
        RegisterAdminChannels()
    else
        admin = false
        bsk.db.profile.admin = false
        UnregisterAdminChannels()
    end
end

function RemoteAdminUpdateReceived(sender,remoteAdminStatusTable)
    if not admin then return end

    local rs = remoteAdminStatusTable
    local events = {} -- record all timestamps seen in this update
    for i,_ in pairs(adminList) do -- update each admin's entry in your own DB

        -- grab the db copy and the incoming copy for that admin
        if not db.profile.adminStatus then db.profile.adminStatus = {} end
        local dbs = db.profile.adminStatus[i] or {base=0, changes={}}
        local ics = rs[i] or {base=0, changes={}}

        -- figure out which is better and keep that one
        -- winning criteria:
        --  * broadcast was actually from that person (ie best
        --  verification possible)
        --  * newer base
        --  * same base, more entries
        --  * todo: see if date last observed is a better option

        if i==sender then
            db.profile.adminStatus[i] = ics
        elseif ics.base > dbs.base or (ics.base==dbs.base and getn(ics.changes) > getn(dbs.changes)) then
            db.profile.adminStatus[i] = ics
        end
    end

    local rss = rs[sender]

    -- now figure out what I'm missing - and ask for it!

    -- construct a hash table of all entries that the sender has / should have
    local entries = {}
    for i,v in pairs(rs) do
        if v.changes then 
            for j,k in pairs(v.changes) do
                entries[k.time] = true
            end
        end
    end
    -- now go back and scrub my own keys from that list
    for i,v in ipairs(db.profile.changes) do
        entries[v.time] = nil
    end
    -- what's left is what I need to ask for
    local request = {}
    for i,v in pairs(entries) do
        if v then table.insert(request,i) end
    end
    table.sort(request)
    Comm:RequestSpecificChanges(request,sender)

    for
        -- specifically leaving this broken. note to self.
        -- this still isn't good enough. it doesn't communicate an admin's
        -- present working state. like if they had put in new changes since
        -- loading up. or learned of some changes to fill in an old gap
end

function InitializeAdmin()
    if not event then
        _G.error("BSK: Improper order of initialization")
    end
    me = _G.UnitName("player")

    if admin then -- if at last login I was an admin ...

        -- note that we're not transmitting anything here. we'll do that once we
        -- know for certain we're an admin

        -- cache the onload status in case it changes in memory later
        onloadAdminStatus = {}
        tcopy(onloadAdminStatus,db.profile.adminStatus)

        -- update our own entry - safe because comms shouldn't have happened yet
        if not onloadAdminStatus then onloadAdminStatus = {} end
        if not onloadAdminStatus[me] then onloadAdminStatus[me] = {} end
        onloadAdminStatus[me].base = db.profile.time or 0
        onloadAdminStatus[me].changes= {}
        for _,v in ipairs(db.profile.changes) do
            table.insert(onloadAdminStatus[me].changes,v.time) -- only timestamps
        end

    else -- otherwise store a blank slate
        onloadAdminStatus = {}
        db.profile.adminStatus = nil
    end

    event:RegisterEvent("GUILD_ROSTER_UPDATE",GuildRosterUpdate)
    _G.GuildRoster() -- will eventually force the event to fire

    if me == "Breuemama" then -- debugging only
        GuildRosterUpdate()
    end
end