-- Prosody IM

-- Copyright (C) 2010 Dai Zhiwei

-- 

-- This project is MIT/X11 licensed. Please see the

-- COPYING file in the source package for more information.

--

local st = require "util.stanza";

local dm = require "util.datamanager";

local jid = require "util.jid";

local datetime = require "util.datetime";

local PREFS_DIR = "archive_prefs";

local ARCHIVE_DIR = "archive";

local xmlns_rsm = "http://jabber.org/protocol/rsm";

local DEFAULT_MAX = 100;

local FORCE_ARCHIVING = false;

local AUTO_ARCHIVING_ENABLED = true;

local HOST = 'localhost';

module:add_feature("urn:xmpp:archive");

module:add_feature("urn:xmpp:archive:auto");

module:add_feature("urn:xmpp:archive:manage");

module:add_feature("urn:xmpp:archive:manual");

module:add_feature("urn:xmpp:archive:pref");

module:add_feature("http://jabber.org/protocol/rsm");

------------------------------------------------------------

-- Utils

------------------------------------------------------------

local function load_prefs(node, host)

    return st.deserialize(dm.load(node, host, PREFS_DIR));

end

local function store_prefs(data, node, host)

    dm.store(node, host, PREFS_DIR, st.preserialize(data));

end

local function os_date()

    return os.date("!*t");

end

local function date_time(t)

    return datetime.datetime(t);

end

local function date_parse(s)

	local year, month, day, hour, min, sec = s:match("(....)-?(..)-?(..)T(..):(..):(..)Z");

	return os.time({year=year, month=month, day=day, hour=hour, min=min, sec=sec});

end

-- local function list_push(node, host, collection)

-- 	local data = dm.list_load(node, host, ARCHIVE_DIR);

--     if data then

--         table.insert(data, collection, 1);

--         dm.list_store(node, host, ARCHIVE_DIR, st.preserialize(data));

--     else

--         dm.list_append(node, host, ARCHIVE_DIR, st.preserialize(collection));

--     end

-- end

local function list_insert(node, host, collection)

	local data = dm.list_load(node, host, ARCHIVE_DIR);

    if data then

        local s, e = 1, #data;

        while true do

            local c = st.deserialize(data[s]);

            if collection.attr["start"] >= c.attr["start"] then

                table.insert(data, collection, s);

                break;

            end

            c = st.deserialize(data[e]);

            if collection.attr["start"] <= c.attr["start"] then

                table.insert(data, collection, e+1);

                break;

            end

            local m = math.floor((s + e) / 2);

            c = st.deserialize(data[m]);

            if collection.attr["start"] > c.attr["start"] then

                e = m - 1;

            elseif collection.attr["start"] < c.attr["start"] then

                s = m + 1;

            else

                table.insert(data, collection, m);

                break;

            end

        end

        dm.list_store(node, host, ARCHIVE_DIR, st.preserialize(data));

    else

        dm.list_append(node, host, ARCHIVE_DIR, st.preserialize(collection));

    end

end

local function store_msg(msg, node, host, isfrom)

    local body = msg:child_with_name("body");

    local thread = msg:child_with_name("thread");

	local data = dm.list_load(node, host, ARCHIVE_DIR);

    local tag = isfrom and "from" or "to";

    local with = isfrom and msg.attr.to or msg.attr.from;

    local utc = os_date();

    local utc_secs = os.time(utc);

    local utc_datetime = date_time(utc);

    if data then

        -- TODO assuming the collection list are in REVERSE chronological order 

        for k, v in ipairs(data) do

            local collection = st.deserialize(v);

                local dt = 1;

                for i = #collection, 1, -1 do

                    local s = collection[i].attr["utc_secs"];

                    if s then

                        dt = os.difftime(utc_secs, tonumber(s));

                        break;

                    end

                end

                collection:tag(tag, {secs=dt, utc_secs=utc_secs}):add_child(body);

                local ver = tonumber(collection.attr["version"]) + 1;

                collection.attr["version"] = tostring(ver);

                collection.attr["access"] = utc_datetime;

                data[k] = collection;

                dm.list_store(node, host, ARCHIVE_DIR, st.preserialize(data));

            end

        end

    end

    -- not found, create new collection

    local collection = st.stanza('chat', {with=with, start=utc_datetime, thread=thread and thread:get_text() or nil, version='0', access=utc_datetime});

    collection:tag(tag, {secs='0', utc_secs=utc_secs}):add_child(body);

    list_insert(node, host, collection);

end

local function save_result(collection)

    local save = st.stanza('save', {xmlns='urn:xmpp:archive'});

    local chat = st.stanza('chat', collection.attr);

    save:add_child(chat);

    return save;

end 

local function gen_uid(c)

    return c.attr["start"] .. c.attr["with"];

end

local function tobool(s)

    if not s then return nil; end

    s = s:lower();

    if s == 'true' or s == '1' then

        return true;

    elseif s == 'false' or s == '0' then

        return false;

    else

        return nil;

    end

end

------------------------------------------------------------

-- Preferences

------------------------------------------------------------

local function preferences_handler(event)

    local origin, stanza = event.origin, event.stanza;

    module:log("debug", "-- Enter preferences_handler()");

    module:log("debug", "-- pref:\n%s", tostring(stanza));

    if stanza.attr.type == "get" then

        local data = load_prefs(origin.username, origin.host);

        if data then

            origin.send(st.reply(stanza):add_child(data));

        else

            local reply = st.reply(stanza):tag('pref', {xmlns='urn:xmpp:archive'});

            reply:tag('default', {otr='concede', save='false', unset='true'}):up();

            reply:tag('method', {type='auto', use='concede'}):up();

            reply:tag('method', {type='local', use='concede'}):up();

            reply:tag('method', {type='manual', use='concede'}):up();

            reply:tag('auto', {save='false'}):up();

            origin.send(reply);

        end

    elseif stanza.attr.type == "set" then

        local node, host = origin.username, origin.host;

        local data = load_prefs(node, host);

        if not data then

            data = st.stanza('pref', {xmlns='urn:xmpp:archive'});

            data:tag('default', {otr='concede', save='false'}):up();

            data:tag('method', {type='auto', use='concede'}):up();

            data:tag('method', {type='local', use='concede'}):up();

            data:tag('method', {type='manual', use='concede'}):up();

            data:tag('auto', {save='false'}):up();

        end

        local elem = stanza.tags[1].tags[1]; -- iq:pref:xxx

        if not elem then return false end

        -- "default" | "item" | "session" | "method"

        elem.attr["xmlns"] = nil; -- TODO why there is an extra xmlns attr?

        if elem.name == "default" then

            local setting = data:child_with_name(elem.name)

            for k, v in pairs(elem.attr) do

                setting.attr[k] = v;

            end

            -- setting.attr["unset"] = nil

        elseif elem.name == "item" then

            local found = false;

            for child in data:children() do

                if child.name == elem.name and child.attr["jid"] == elem.attr["jid"] then

                    for k, v in pairs(elem.attr) do

                        child.attr[k] = v;

                    end

                    found = true;

                    break;

                end

            end

            if not found then

                data:tag(elem.name, elem.attr):up();

            end

        elseif elem.name == "session" then

            local found = false;

            for child in data:children() do

                if child.name == elem.name and child.attr["thread"] == elem.attr["thread"] then

                    for k, v in pairs(elem.attr) do

                        child.attr[k] = v;

                    end

                    found = true;

                    break;

                end

            end

            if not found then

                data:tag(elem.name, elem.attr):up();

            end

        elseif elem.name == "method" then

            local newpref = stanza.tags[1]; -- iq:pref

            for _, e in ipairs(newpref.tags) do

                -- if e.name ~= "method" then continue end

                local found = false;

                for child in data:children() do

                    if child.name == "method" and child.attr["type"] == e.attr["type"] then

                        child.attr["use"] = e.attr["use"];

                        found = true;

                        break;

                    end

                end

                if not found then

                    data:tag(e.name, e.attr):up();

                end

            end

        end

        store_prefs(data, node, host);

        origin.send(st.reply(stanza));

        local user = bare_sessions[node.."@"..host];

        local push = st.iq({type="set"});

        push = push:tag('pref', {xmlns='urn:xmpp:archive'});

        if elem.name == "method" then

            for child in data:children() do

                if child.name == "method" then

                    push:add_child(child);

                end

            end

        else

            push:add_child(elem);

        end

        push = push:up();

        for _, res in pairs(user and user.sessions or NULL) do -- broadcast to all resources

            if res.presence then -- to resource

                push.attr.to = res.full_jid;

                res.send(push);

            end

        end

    end

    return true;

end

local function itemremove_handler(event)

    -- TODO use 'assert' to check incoming stanza?

    -- or use pcall() to catch exceptions?

    local origin, stanza = event.origin, event.stanza;

    if stanza.attr.type ~= "set" then

        return false;

    end

    local elem = stanza.tags[1].tags[1];

    if not elem or elem.name ~= "item" then

        return false;

    end

    local node, host = origin.username, origin.host;

    local data = load_prefs(node, host);

    if not data then

        return false;

    end

    for i, child in ipairs(data) do

        if child.name == "item" and child.attr["jid"] == elem.attr["jid"] then

            table.remove(data, i)

            break;

        end

    end

    store_prefs(data, node, host);

    origin.send(st.reply(stanza));

    return true;

end

local function sessionremove_handler(event)

    local origin, stanza = event.origin, event.stanza;

    if stanza.attr.type ~= "set" then

        return false;

    end

    local elem = stanza.tags[1].tags[1];

    if not elem or elem.name ~= "session" then

        return false;

    end

    local node, host = origin.username, origin.host;

    local data = load_prefs(node, host);

    if not data then

        return false;

    end

    for i, child in ipairs(data) do

        if child.name == "session" and child.attr["thread"] == elem.attr["thread"] then

            table.remove(data, i)

            break;

        end

    end

    store_prefs(data, node, host);

    origin.send(st.reply(stanza));

    return true;

end

local function auto_handler(event)

    -- event.origin.send(st.error_reply(event.stanza, "cancel", "feature-not-implemented"));

    local origin, stanza = event.origin, event.stanza;

    if stanza.attr.type ~= "set" then

        return false;

    end

    local elem = stanza.tags[1];

    local node, host = origin.username, origin.host;

    local data = load_prefs(node, host);

        return false;

    end

    local setting = data:child_with_name(elem.name)

    for k, v in pairs(elem.attr) do

        setting.attr[k] = v;

    end

    store_prefs(data, node, host);

    origin.send(st.reply(stanza));

    return true;

end

------------------------------------------------------------

-- Manual Archiving