%%% ====================================================================
%%% ``The contents of this file are subject to the Erlang Public License,
%%% Version 1.1, (the "License"); you may not use this file except in
%%% compliance with the License. You should have received a copy of the
%%% Erlang Public License along with this software. If not, it can be
%%% retrieved via the world wide web at http:%%www.erlang.org/.
%%% 
%%% Software distributed under the License is distributed on an "AS IS"
%%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%%% the License for the specific language governing rights and limitations
%%% under the License.
%%% 
%%% The Initial Developer of the Original Code is ProcessOne.
%%% Portions created by ProcessOne are Copyright 2006-2013, ProcessOne
%%% All Rights Reserved.''
%%% This software is copyright 2006-2013, ProcessOne.
%%%
%%% @copyright 2006-2013 ProcessOne
%%% @author Karim Gemayel <karim.gemayel@process-one.net>
%%%   [http:%%www.process-one.net/]
%%% @version {@vsn}, {@date} {@time}
%%% @end
%%% ====================================================================

%%% @headerfile "pubsub_dev.hrl"

-module(pubsub_db_mnesia).
-author('karim.gemayel@process-one.net').

-compile(export_all).

-include("pubsub_dev.hrl").
-include("pubsub_api.hrl").


-import(pubsub_tools,
[
  get_option/2,
  get_option/3,
  get_value/2,
  get_value/3,
  set_value/3,
  %%
  check_access_model/3,
  check_access_model/7,
  check_publish_model/3,
  is_contact_subscribed_to_node_owners/3,
  is_contact_in_allowed_roster_groups/2,
  has_subscriptions/1
]).


-export_type([
  suffix/0,
  table/0
]).

-type(suffix() :: undefined | atom()).
-type(table() :: atom()).


%%
-spec(init/1 ::
(
  Suffix :: undefined | atom())
    -> 'ok'
).

init(Suffix) ->
    create_table_pubsub_node(Suffix),
    create_table_pubsub_state(Suffix),
    create_table_pubsub_item(Suffix),
    create_table_pubsub_last_item(Suffix),
    create_table_pubsub_subscription_pending(Suffix),
    pubsub_index_dev:init(Suffix),
    pubsub_groups:create_table_pubsub_groups(Suffix).

%%
-spec(table/2 ::
(
  Base_Table :: atom(),
  Suffix     :: undefined | atom())
    -> Table :: atom()
).

table(Base_Table, undefined = _Suffix) ->
    _Table = Base_Table;
table(Base_Table, Suffix) ->
    _Table = list_to_atom(atom_to_list(Base_Table) ++ "_" ++ atom_to_list(Suffix)).


%%
create_table_pubsub_node(Suffix) ->
    mnesia:create_table(table('pubsub_node', Suffix),
        [{type, set},
         {disc_copies, [node()]},
         {record_name, pubsub_node_dev},
         {attributes, record_info(fields, pubsub_node_dev)}]),
    mnesia:add_table_index(pubsub_node_dev, idx).

create_table_pubsub_state(Suffix) ->
    mnesia:create_table(table('pubsub_state', Suffix),
        [{type, set},
         {disc_copies, [node()]},
         {record_name, pubsub_state_dev},
         {attributes, record_info(fields, pubsub_state_dev)}]),
    mnesia:add_table_index(pubsub_state_dev, nodeidx).

create_table_pubsub_item(Suffix) ->
    mnesia:create_table(table('pubsub_item', Suffix),
        [{type, set},
         {disc_copies, [node()]},
         {record_name, pubsub_item_dev},
         {attributes, record_info(fields, pubsub_item_dev)}]),
    mnesia:add_table_index(pubsub_item_dev, nodeidx).

create_table_pubsub_last_item(Suffix) ->
    mnesia:create_table(table('pubsub_last_item', Suffix),
        [{type, set},
         {disc_copies, [node()]},
         {record_name, pubsub_last_item_dev},
         {attributes, record_info(fields, pubsub_last_item_dev)}]).

create_table_pubsub_subscription_pending(Suffix) ->
    mnesia:create_table(table('pubsub_subscription_pending', Suffix),
        [{type, set},
         {disc_copies, [node()]},
         {record_name, pubsub_subscription_pending},
         {attributes, record_info(fields, pubsub_subscription_pending)}]),
    mnesia:add_table_index(pubsub_subscription_pending, nodeidx).

%%
transaction(Module, Function, Arguments) ->
    case mnesia:transaction(fun() -> apply(Module, Function, Arguments) end) of
        {atomic, Result} ->
            Result;
        {aborted, Reason} ->
            ?INFO_MSG("DB TRANSACTION ERROR ~p", [Reason]),
            {error, 'internal-server-error'}
    end.

%%
-spec(read_item/3 ::
(
  Suffix  :: atom(),
  NodeIdx :: exmpp_pubsub:nodeIdx(),
  ItemId  :: exmpp_pubsub:itemId())
    -> Pubsub_Item :: undefined | mod_pubsub_dev:pubsub_item()
).

read_item(Suffix, NodeIdx, ItemId) ->
    _Pubsub_Item = case
        mnesia:read({_Table = table('pubsub_item', Suffix), {ItemId, NodeIdx}})
    of
        [Pubsub_Item] -> Pubsub_Item;
        []            -> undefined
    end.

%%
-spec(read_node/3 ::
(
  Suffix      :: atom(),
  Pubsub_Host :: exmpp_pubsub:host(),
  NodeId      :: exmpp_pubsub:nodeId())
    -> Pubsub_Node :: undefined | mod_pubsub_dev:pubsub_node()
).

read_node(Suffix, Pubsub_Host, NodeId) ->
    _Pubsub_Node = case
        mnesia:read({_Table = table('pubsub_node', Suffix),
            {Pubsub_Host, NodeId}})
    of
        [Pubsub_Node] -> Pubsub_Node;
        []            -> undefined
    end.

%%
-spec(read_state/3 ::
(
  Suffix  :: atom(),
  Entity  :: xmpp_jid:usr_entity(),
  NodeIdx :: exmpp_pubsub:nodeIdx())
    -> Pubsub_State :: undefined | mod_pubsub_dev:pubsub_state()
).

read_state(Suffix, {U,S,_R} = _Entity, NodeIdx) ->
    _Pubsub_State = case
        mnesia:read({_Table = table('pubsub_state', Suffix),
            {{U,S,undefined}, NodeIdx}})
    of
        [Pubsub_State] -> Pubsub_State;
        []             -> undefined
    end.

%%
-spec(index_read_node/2 ::
(
  Suffix  :: atom(),
  NodeIdx :: exmpp_pubsub:nodeIdx())
    -> Pubsub_Nodes::[Pubsub_Node::mod_pubsub_dev:pubsub_node()]
).

index_read_node(Suffix, NodeIdx) ->
    _Pubsub_Nodes = mnesia:index_read(_Table = table('pubsub_node', Suffix),
        NodeIdx, idx).

%%
-spec(index_read_state/2 ::
(
  Suffix  :: atom(),
  NodeIdx :: exmpp_pubsub:nodeIdx())
    -> Pubsub_States::[Pubsub_State::mod_pubsub_dev:pubsub_state()]
).

index_read_state(Suffix, NodeIdx) ->
    _Pubsub_States = mnesia:index_read(_Table = table('pubsub_state', Suffix),
        NodeIdx, nodeidx).


%-- Create_Node --%
-spec(create_node/7 ::
(
  Suffix          :: atom(),
  Pubsub_Host     :: exmpp_pubsub:host(),
  Entity          :: xmpp_jid:usr_entity(),
  NodeId          :: exmpp_pubsub:nodeId(),
  Level           :: exmpp_pubsub:level(),
  Node_Options    :: pubsub_options:options_node(),
  Pubsub_Features :: exmpp_pubsub:pubsub_features())
    -> Subscription :: undefined | exmpp_pubsub:subscription_subscribed()
).

create_node(Suffix, Pubsub_Host, {U,S,R} = _Entity, NodeId, Level, Node_Options,
  Pubsub_Features) ->
    %% Create Pubsub_Node
    mnesia:write(table('pubsub_node', Suffix),
        #pubsub_node_dev{
            id       = {Pubsub_Host, NodeId},
            idx      = NodeIdx = pubsub_index_dev:new(Suffix, 'node'),
            level    = Level,
            creation = {_DateTime = now(), _Creator = {U,S,R}},
            owners   = [{U,S,undefined}],
            options  = Node_Options
        },
        write),
    _Subscription = case
        lists:member(<<"auto-subscribe">>, Pubsub_Features)
            andalso
        get_value(Node_Options, 'subscribe', false)
    of
        true ->
            mnesia:write(table('pubsub_state', Suffix),
                #pubsub_state_dev{
                    id            = {{U,S,undefined}, NodeIdx},
                    nodeidx       = NodeIdx,
                    affiliation   = 'owner',
                    subscriptions = [Subscription = {
                        _Subscription_State = 'subscribed',
                        _SubId = exmpp_pubsub:subId(),
                        _Resource = undefined,
                        _Subscription_Options = []
                    }]
                },
                write),
            Subscription;
        false ->
            mnesia:write(table('pubsub_state', Suffix),
                #pubsub_state_dev{
                    id          = {{U,S,undefined}, NodeIdx},
                    nodeidx     = NodeIdx,
                    affiliation = 'owner'
                },
                write),
            undefined
    end.

%-- Purge_Node --%
%% TODO : purge Pubsub_Purge_Offline
%% TODO : purge Pubsub_Expiry_Item
-spec(purge_node/2 ::
(
  Suffix      :: atom(),
  Pubsub_Node :: mod_pubsub_dev:pubsub_node())
    -> Recipients :: undefined | [Entity::xmpp_jid:usr_bare()]
).

purge_node(Suffix, Pubsub_Node) ->
    %% Update Pubsub_Node
    mnesia:write(table('pubsub_node', Suffix),
        Pubsub_Node#pubsub_node_dev{itemids = []}, write),
    %% Delete Pubsub_Last_Item
    mnesia:delete(table('pubsub_last_item', Suffix),
        NodeIdx = Pubsub_Node#pubsub_node_dev.idx, write),
    %%
    Table_Pubsub_State = table('pubsub_state', Suffix),
    Table_Pubsub_Item = table('pubsub_item', Suffix),
    _Recipients = case
        get_value(Pubsub_Node#pubsub_node_dev.options, 'notify_retract', false)
    of
        true ->
            %% Delete Pubsub_Items
            lists:foreach(fun
                (Pubsub_Item) ->
                    mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item, write)
                %
            end, _Pubsub_Items = mnesia:index_read(Table_Pubsub_Item, NodeIdx,
                     nodeidx)),
            %% Update Pubsub_States
            _Subscribers = lists:foldl(fun
                %%
                (Pubsub_State, Subscribers)
                  when (Pubsub_State#pubsub_state_dev.affiliation == 'owner'
                            orelse
                        Pubsub_State#pubsub_state_dev.affiliation == 'outcast'
                            orelse
                        Pubsub_State#pubsub_state_dev.affiliation == 'publish-only')
                  andalso Pubsub_State#pubsub_state_dev.itemids =/= [] ->
                    mnesia:write(Table_Pubsub_State,
                        Pubsub_State#pubsub_state_dev{itemids = []},
                        write),
                    Subscribers;
                %%
                (#pubsub_state_dev{id = {Entity, _NodeIdx}} = Pubsub_State,
                 Subscribers)
                  when    Pubsub_State#pubsub_state_dev.affiliation == 'publisher'
                  andalso Pubsub_State#pubsub_state_dev.itemids     =/= [] ->
                    mnesia:write(Table_Pubsub_State,
                        Pubsub_State#pubsub_state_dev{itemids = []}, write),
                    case Pubsub_State#pubsub_state_dev.subscriptions of
                        [] = _Subscriptions ->
                            Subscribers;
                        _Subscriptions ->
                            [_Subscriber = Entity | Subscribers]
                    end;
                %%
                (#pubsub_state_dev{id = {Entity, _NodeIdx}} = Pubsub_State,
                 Subscribers)
                  when    Pubsub_State#pubsub_state_dev.affiliation   == 'publisher'
                  andalso Pubsub_State#pubsub_state_dev.subscriptions =/= [] ->
                    [_Subscriber = Entity | Subscribers];
                %%
                (#pubsub_state_dev{id = {Entity, _NodeIdx}} = Pubsub_State,
                 Subscribers)
                  when    Pubsub_State#pubsub_state_dev.affiliation == 'member'
                  andalso Pubsub_State#pubsub_state_dev.itemids     =/= [] ->
                    mnesia:write(Table_Pubsub_State,
                        Pubsub_State#pubsub_state_dev{itemids = []}, write),
                    case
                        (Pubsub_State#pubsub_state_dev.subscriptions == []
                             orelse
                         has_subscriptions(
                             Pubsub_State#pubsub_state_dev.subscriptions))
                    of
                        true  -> [_Subscriber = Entity | Subscribers];
                        false -> Subscribers
                    end;
                %%
                (#pubsub_state_dev{id = {Entity, _NodeIdx}} = Pubsub_State,
                 Subscribers)
                  when Pubsub_State#pubsub_state_dev.affiliation == 'member'->
                    case
                        (Pubsub_State#pubsub_state_dev.subscriptions == []
                             orelse
                         has_subscriptions(
                             Pubsub_State#pubsub_state_dev.subscriptions))
                    of
                        true  -> [_Subscriber = Entity | Subscribers];
                        false -> Subscribers
                    end;
                %%
                (_Pubsub_State, Subscribers) ->
                    Subscribers
                %
            end,
                [],
                    _Pubsub_States = mnesia:index_read(Table_Pubsub_State,
                        NodeIdx, nodeidx));
        false ->
            %% Update Pubsub_States
            lists:foreach(fun
                (_Items_Owner = Entity) ->
                    case
                        mnesia:read(Table_Pubsub_State, {Entity, NodeIdx},
                            write)
                    of
                        [Pubsub_State]
                          when Pubsub_State#pubsub_state_dev.itemids =/= [] ->
                            mnesia:write(Table_Pubsub_State,
                                Pubsub_State#pubsub_state_dev{itemids = []},
                                    write);
                        _Pubsub_State ->
                            ok
                    end
            end,
                _Items_Owners = lists:foldl(fun
                    %% Delete Pubsub_Items
                    (Pubsub_Item, Items_Owners) ->
                        mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item,
                            write),
                        lists:usort(lists:append(Items_Owners,
                            Pubsub_Item#pubsub_item_dev.owners))
                end, [],
                    _Pubsub_Items = mnesia:index_read(Table_Pubsub_Item, NodeIdx,
                        nodeidx))
            ),
            _Subscribers = undefined
    end.

%-- Delete_Node --%
-spec(delete_node/2 ::
(
  Suffix      :: atom(),
  Pubsub_Node :: mod_pubsub_dev:pubsub_node())
    -> Recipients :: undefined | [Entity::xmpp_jid:usr_bare()]
).

delete_node(Suffix, Pubsub_Node) ->
    %% Delete Pubsub_Node
    mnesia:delete_object(table('pubsub_node', Suffix), Pubsub_Node, write),
    pubsub_index_dev:free(Suffix, 'node',
        NodeIdx = Pubsub_Node#pubsub_node_dev.idx),
    %% Delete Pubsub_Last_Item
    mnesia:delete(table('pubsub_last_item', Suffix), NodeIdx, write),
    %% Delete Pubsub_Items
    Table_Pubsub_Item = table('pubsub_item', Suffix),
    lists:foreach(fun
        (Pubsub_Item) ->
            mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item, write)
        %
    end,
        _Pubsub_Items = mnesia:index_read(Table_Pubsub_Item, NodeIdx,
            nodeidx)),
    %% Delete Pubsub_States
    Table_Pubsub_State = table('pubsub_state', Suffix),
    _Recipients = case
        get_value(Pubsub_Node#pubsub_node_dev.options, 'notify_delete', false)
    of
        true ->
            _Subscribers = lists:foldl(fun
                (#pubsub_state_dev{id = {Entity, _NodeIdx}} = Pubsub_State,
                 Subscribers) ->
                    mnesia:delete_object(Table_Pubsub_State, Pubsub_State,
                        write),
                    case
                        {Pubsub_State#pubsub_state_dev.affiliation,
                         Pubsub_State#pubsub_state_dev.subscriptions}
                    of
                        %%
                        {'publisher' = _Affiliation, Subscriptions}
                          when Subscriptions =/= [] ->
                            [_Subscriber = Entity | Subscribers];
                        %%
                        {'member' = _Affiliation, _Subscriptions} ->
                            case
                                (_Subscriptions == []
                                     orelse
                                 has_subscriptions(_Subscriptions))
                            of
                                true ->
                                    [_Subscriber = Entity | Subscribers];
                                false ->
                                    Subscribers
                            end;
                        %%
                        {_Affiliation, _Subscriptions} ->
                            Subscribers
                    end
                %
            end, [],
                _Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx,
                    nodeidx));
        false ->
            lists:foreach(fun
                (Pubsub_State) ->
                    mnesia:delete_object(Table_Pubsub_State, Pubsub_State,
                        write)
            end,
                _Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx,
                    nodeidx)),
            _Subscribers = undefined
    end.

%-- Get_Entity_Subscriptions --%
-spec(get_entity_subscriptions/4 ::
(
  Suffix      :: atom(),
  Pubsub_Host :: exmpp_pubsub:host(),
  Entity      :: xmpp_jid:usr_entity(),
  NodeId      :: undefined | exmpp_pubsub:nodeId())
    -> Entity_Subscriptions :: [{
           NodeId        :: exmpp_pubsub:nodeId(),
           Subscriptions :: exmpp_pubsub:subscriptions()
       }]
).

get_entity_subscriptions(Suffix, Pubsub_Host, {U,S,_R} = _Entity,
  undefined = _NodeId) ->
    Table_Pubsub_Node = table('pubsub_node', Suffix),
    _Entity_Subscriptions = lists:foldl(fun
        ([NodeIdx, Subscriptions], Entity_Subscriptions) ->
            case mnesia:index_read(Table_Pubsub_Node, NodeIdx, idx) of
                %% IMPORTANT : Pubsub_Host must be used in the matching,
                %% else it'd return all NodeIds subscriptions (in case of VHosts)
                %% and not only the ones from to the current Pubsub_Host
                [#pubsub_node_dev{id = {Pubsub_Host, NodeId}}] ->
                    [{NodeId, Subscriptions} | Entity_Subscriptions];
                _Pubsub_Node ->
                    Entity_Subscriptions
            end
    end, [],
        mnesia:select(table('pubsub_state', Suffix),
            [{#pubsub_state_dev{
                  id            = {{U,S,undefined}, '$1'},
                  subscriptions = '$2',
                  _             = '_'},
            [{'=/=', '$2', []}],
            ['$$']}]));
%%
get_entity_subscriptions(Suffix, Pubsub_Host, {U,S,_R} = _Entity, NodeId) ->
    _Entity_Subscriptions = case
        mnesia:read(table('pubsub_node', Suffix), {Pubsub_Host, NodeId}, read)
    of
        [] ->
            [];
        [#pubsub_node_dev{idx = NodeIdx}] ->
            case
                mnesia:read(table('pubsub_state', Suffix),
                    {{U,S,undefined}, NodeIdx}, read)
            of
                [#pubsub_state_dev{subscriptions = Subscriptions}]
                  when Subscriptions =/= [] ->
                    [{NodeId, Subscriptions}];
                _Pubsub_State ->
                    []
            end
    end.

%-- Get_Entity_Affiliations --%
-spec(get_entity_affiliations/4 ::
(
  Suffix      :: atom(),
  Pubsub_Host :: exmpp_pubsub:host(),
  Entity      :: xmpp_jid:usr_bare(),
  NodeId      :: undefined | exmpp_pubsub:nodeId())
    -> Entity_Affiliations :: [Entity_Affiliation :: {
           NodeId      :: exmpp_pubsub:nodeId(),
           Affiliation :: exmpp_pubsub:affiliation()
       }]
).

get_entity_affiliations(Suffix, Pubsub_Host, {U,S,_R} = _Entity,
  undefined = _NodeId) ->
    Table_Pubsub_Node = table('pubsub_node', Suffix),
    _Entity_Affiliations = lists:foldl(fun
        ([NodeIdx, Affiliation], Entity_Affiliations) ->
            case mnesia:index_read(Table_Pubsub_Node, NodeIdx, idx) of
                %% IMPORTANT : Pubsub_Host must be used in the matching,
                %% else it'd return all NodeIds affiliations (in case of VHosts)
                %% and not only the ones from to the current Pubsub_Host
                [#pubsub_node_dev{id = {Pubsub_Host, NodeId}}] ->
                    [{NodeId, Affiliation} | Entity_Affiliations];
                _Pubsub_Node ->
                    Entity_Affiliations
            end
    end, [],
        mnesia:select(table('pubsub_state', Suffix),
            [{#pubsub_state_dev{
                  id          = {{U,S,undefined}, '$1'},
                  affiliation = '$2',
                  _           = '_'},
             [],
             ['$$']}],
             read)
        );
%%
get_entity_affiliations(Suffix, Pubsub_Host, {U,S,_R} = _Entity, NodeId) ->
    _Entity_Affiliations = case
        mnesia:read(table('pubsub_node', Suffix), {Pubsub_Host, NodeId}, read)
    of
        [] ->
            [];
        [#pubsub_node_dev{idx = NodeIdx}] ->
            case
                mnesia:read(table('pubsub_state', Suffix),
                    {{U,S,undefined}, NodeIdx})
            of
                [#pubsub_state_dev{affiliation = Affiliation}] ->
                    [{NodeId, Affiliation}];
                _Pubsub_State ->
                    []
            end
    end.

%-- Publish_Item --%
-spec(publish_item1/9 ::
(
  Suffix          :: atom(),
  Pubsub_Host     :: exmpp_pubsub:host(),
  Entity          :: xmpp_jid:usr_entity(),
  NodeId          :: undefined | exmpp_pubsub:nodeId(),
  Level           :: exmpp_pubsub:level(),
  ItemId          :: undefined | exmpp_pubsub:itemId(),
  Payload         :: [Xmlel::#xmlel{}] | exmpp_pubsub:payload(),
  Options         :: {Node_Options :: pubsub_options:options_node(),
                      Item_Options :: [] | pubsub_options:options_item()},
  Pubsub_Features :: exmpp_pubsub:pubsub_features())
    -> {ItemId             :: exmpp_pubsub:itemId(),
        Pubsub_State@Owner :: mod_pubsub_dev:pubsub_state_owner()}
).

publish_item1(Suffix, Pubsub_Host, Entity, NodeId, Level, ItemId,
  [Payload], Options, Pubsub_Features) ->
    publish_item1(Suffix, Pubsub_Host, Entity, NodeId, Level, ItemId, Payload,
        Options, Pubsub_Features);

publish_item1(Suffix, Pubsub_Host, Entity, NodeId, Level, undefined = _ItemId,
  Payload, Options, Pubsub_Features) ->
    publish_item1(Suffix, Pubsub_Host, Entity, NodeId, Level,
        exmpp_pubsub:itemId(), Payload, Options, Pubsub_Features);
%%
publish_item1(Suffix, Pubsub_Host, {U,S,R} = _Entity, NodeId, Level, ItemId,
  Payload, {Node_Options, Item_Options} = Options, Pubsub_Features) ->
    NodeIdx = pubsub_index_dev:new(Suffix, 'node'),
    DateTime = now(),
    Write_Item = get_value(Options, 'persist_items', false) andalso
        (get_value(Node_Options, 'max_items', 0) > 0),
    %% Create Pubsub_Node
    mnesia:write(table('pubsub_node', Suffix),
        #pubsub_node_dev{
            id       = {Pubsub_Host, NodeId},
            idx      = NodeIdx,
            creation = {DateTime, _Creator = {U,S,R}},
            level    = Level,
            owners   = [{U,S,undefined}],
            itemids  = case Write_Item of
                true  -> [ItemId];
                false -> []
            end,
            options  = Node_Options
        },
        write),
    %% Create Pubsub_Item
    case Write_Item of
        false ->
            ok;
        true ->
            mnesia:write(table('pubsub_item', Suffix),
                #pubsub_item_dev{
                    id       = {ItemId, NodeIdx},
                    nodeidx  = NodeIdx,
                    owners   = [{U,S,undefined}],
                    creation = {DateTime, _Creator = {U,S,R}},
                    payload  = Payload,
                    options  = Item_Options
                },
                write),
            %%TODO : Register pubsub#item_expire
            case get_value(Options, 'item_expire', undefined) of
                undefined ->
                    ko;
                Delay ->
                    ok
            end
    end,
    %% Create Pubsub_Last_Item
    case get_value(Options, 'send_last_published_item', 'never') of
        'never' ->
            ok;
        _Send_Last_Published_Item ->
            mnesia:write(table('pubsub_last_item', Suffix),
                #pubsub_last_item_dev{
                    nodeidx  = NodeIdx,
                    id       = ItemId,
                    owners   = [{U,S,undefined}],
                    creation = {DateTime, _Creator = {U,S,R}},
                    payload  = Payload,
                    options  = Item_Options
                },
                write)
    end,
    %% Create Pubsub_State
    mnesia:write(table('pubsub_state', Suffix),
        Pubsub_State = #pubsub_state_dev{
            id            = {{U,S,undefined}, NodeIdx},
            nodeidx       = NodeIdx,
            itemids       = case Write_Item of
                true  -> [ItemId];
                false -> []
            end,
            affiliation   = 'owner',
            subscriptions = case
                lists:member(<<"auto-subscribe">>, Pubsub_Features)
                    andalso
                get_value(Node_Options, 'subscribe', false)
            of
                true  ->
                    [{_Subscription_State = 'subscribed',
                      _SubId = exmpp_pubsub:subId(),
                      _Resource = undefined,
                      _Subscription_Options = []}];
                false ->
                    []
            end
        },
        write),
    {ItemId, Pubsub_State}.

%%
-spec(publish_item2/9 ::
(
  Suffix          :: atom(),
  Pubsub_Host     :: exmpp_pubsub:host(),
  Entity          :: xmpp_jid:usr_entity(),
  Pubsub_State    :: undefined | mod_pubsub_dev:pubsub_state(),
  Pubsub_Node     :: mod_pubsub_dev:pubsub_node(),
  _               :: undefined | exmpp_pubsub:itemId() | mod_pubsub_dev:pubsub_item(),
  Payload         :: [Xmlel::#xmlel{}] | exmpp_pubsub:payload(),
  Options         :: {Node_Options :: pubsub_options:options_node(),
                      Item_Options :: [] | pubsub_options:options_item()},
  Pubsub_Features :: exmpp_pubsub:pubsub_features())
    -> {ItemId          :: exmpp_pubsub:itemId(),
        Retracted_Items :: [Retracted_Item::{
            ItemId       :: exmpp_pubsub:itemId(),
            Item_Options :: [] | pubsub_options:options_node()
        }],
        Pubsub_States   :: [Pubsub_State::mod_pubsub_dev:pubsub_state(),...]}
).


publish_item2(Suffix, Pubsub_Host, Entity, Pubsub_State, Pubsub_Node, Pubsub_Item,
  [Payload], Item_Options, Pubsub_Features) ->
    publish_item2(Suffix, Pubsub_Host, Entity, Pubsub_State, Pubsub_Node,
        Pubsub_Item, Payload, Item_Options, Pubsub_Features);
%%
publish_item2(Suffix, Pubsub_Host, {U,S,R} = _Entity, Pubsub_State, Pubsub_Node,
  #pubsub_item_dev{id = {ItemId, NodeIdx}} = Pubsub_Item, Payload, Item_Options,
  Pubsub_Features) ->
    Node_Options = Pubsub_Node#pubsub_node_dev.options,
    DateTime = now(),
    Table_Pubsub_State = table('pubsub_state', Suffix),
    _Retracted_Items = case
        {get_value(Node_Options, 'persist_items', false),
         get_value(Node_Options, 'max_items', 0)}
    of
        %%
        {Persist_Items, Max_Items}
          when   Persist_Items == false
          orelse Max_Items     == 0 ->
            case Pubsub_State of
                undefined ->
                    mnesia:write(table('pubsub_state', Suffix),
                        #pubsub_state_dev{
                            id      = {{U,S,undefined}, NodeIdx},
                            nodeidx = NodeIdx
                        },
                        write),
                    [];
                _Pubsub_State ->
                    []
            end;
        %%
        {true, undefined} ->
            mnesia:write(table('pubsub_node', Suffix),
                Pubsub_Node#pubsub_node_dev{
                    itemids = lists:reverse([ItemId
                        | lists:reverse(lists:delete(ItemId,
                                Pubsub_Node#pubsub_node_dev.itemids))])
                },
                write),
            %%
            mnesia:write(Table_Pubsub_State,
                case Pubsub_State of
                    undefined ->
                        #pubsub_state_dev{
                            id      = {{U,S,undefined}, NodeIdx},
                            nodeidx = NodeIdx,
                            itemids = [ItemId]
                        };
                    _ ->
                        Pubsub_State#pubsub_state_dev{
                            itemids = [ItemId | lists:delete(ItemId,
                                Pubsub_State#pubsub_state_dev.itemids)]
                        }
                end,
                write),
            mnesia:write(table('pubsub_item', Suffix),
                Pubsub_Item#pubsub_item_dev{
                    modification = {DateTime, {U,S,R}},
                    payload      = Payload,
                    options      = Item_Options,
                    owners       = [{U,S,undefined} |
                        lists:delete({U,S,undefined},
                            Pubsub_Item#pubsub_item_dev.owners)]
                },
                write),
            [];
        {true, Max_Items} ->
            {New_ItemIds, Old_ItemIds} = max_items(Max_Items,
                lists:reverse([ItemId
                    | lists:reverse(lists:delete(ItemId,
                          Pubsub_Node#pubsub_node_dev.itemids))])),
            {Retracted_Items, Publisher_Retracted_ItemIds} =
                delete_old_items(Suffix,
                    _Publisher = {U,S,undefined},
                    NodeIdx,
                    _Notify_Retract = get_value(Node_Options,
                        'notify_retract', false),
                    Old_ItemIds, {[], {[], []}}),
            %%
            mnesia:write(table('pubsub_node', Suffix),
                Pubsub_Node#pubsub_node_dev{
                    itemids = New_ItemIds
                },
                write),
            mnesia:write(table('pubsub_item', Suffix),
                Pubsub_Item#pubsub_item_dev{
                    modification = {DateTime, {U,S,R}},
                    payload      = Payload,
                    options      = Item_Options,
                    owners       = [{U,S,undefined} |
                        lists:delete({U,S,undefined},
                            Pubsub_Item#pubsub_item_dev.owners)]
                },
                write),
            mnesia:write(Table_Pubsub_State,
                case Pubsub_State of
                    undefined ->
                        #pubsub_state_dev{
                            id      = {{U,S,undefined}, NodeIdx},
                            nodeidx = NodeIdx,
                            itemids = [ItemId]
                        };
                    _ ->
                        Pubsub_State#pubsub_state_dev{
                            itemids = [ItemId
                                | lists:foldl(fun
                                        (Publisher_Retracted_ItemId,
                                            Publisher_ItemIds) ->
                                                lists:delete(
                                                    Publisher_Retracted_ItemId,
                                                    Publisher_ItemIds)
                                    end,
                                        lists:delete(ItemId,
                                            Pubsub_State#pubsub_state_dev.itemids),
                                                Publisher_Retracted_ItemIds)]
                        }
                end,
                write),
                Retracted_Items

    end,
    case get_value(Node_Options, 'send_last_published_item', 'never') of
        'never' ->
            ok;
        _Send_Last_Published_Item ->
            mnesia:write(table('pubsub_last_item', Suffix),
                #pubsub_last_item_dev{
                    nodeidx  = NodeIdx,
                    id       = ItemId,
                    owners   = [{U,S,undefined}],
                    creation = {DateTime, _Creator = {U,S,R}},
                    payload  = Payload,
                    options  = Item_Options
                },
                write)
    end,
    {ItemId, _Retracted_Items,
     _Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx, nodeidx)};
%%
publish_item2(Suffix, Pubsub_Host, {U,S,R} = Entity, Pubsub_State, Pubsub_Node,
  _ItemId, Payload, Item_Options, Pubsub_Features) ->
    NodeIdx = Pubsub_Node#pubsub_node_dev.idx,
    Node_Options = Pubsub_Node#pubsub_node_dev.options,
    ItemId = case _ItemId of
        undefined -> exmpp_pubsub:itemId();
        _         -> _ItemId
    end,
    DateTime = now(),
    Table_Pubsub_State = table('pubsub_state', Suffix),
    _Retracted_Items = case
        {get_value(Node_Options, 'persist_items', false),
         get_value(Node_Options, 'max_items', 0)}
    of
        %%
        {Persist_Items, Max_Items}
          when   Persist_Items == false
          orelse Max_Items     == 0 ->
            case Pubsub_State of
                undefined ->
                    mnesia:write(Table_Pubsub_State,
                        #pubsub_state_dev{
                            id      = {{U,S,undefined}, NodeIdx},
                            nodeidx = NodeIdx
                        },
                        write),
                    [];
                _Pubsub_State ->
                    []
            end;
        %%
        {true, undefined} ->
            mnesia:write(table('pubsub_node', Suffix),
                Pubsub_Node#pubsub_node_dev{
                    itemids = lists:reverse([ItemId
                        | lists:reverse(ItemId,
                              Pubsub_Node#pubsub_node_dev.itemids)])
                },
                write),
            %%
            mnesia:write(Table_Pubsub_State,
                case Pubsub_State of
                    undefined ->
                        #pubsub_state_dev{
                            id      = {{U,S,undefined}, NodeIdx},
                            nodeidx = NodeIdx,
                            itemids = [ItemId]
                        };
                    _ ->
                        Pubsub_State#pubsub_state_dev{
                            itemids = [ItemId |
                                Pubsub_State#pubsub_state_dev.itemids]
                        }
                end,
                write),
                mnesia:write(table('pubsub_item', Suffix),
                    #pubsub_item_dev{
                        id       = {ItemId, NodeIdx},
                        nodeidx  = NodeIdx,
                        owners   = [{U,S,undefined}],
                        creation = {DateTime, {U,S,R}},
                        payload  = Payload,
                        options  = Item_Options
                    },
                    write),
                [];
            {true, Max_Items} ->
                {New_ItemIds, Old_ItemIds} = max_items(Max_Items,
                    lists:reverse([ItemId
                        | lists:reverse(Pubsub_Node#pubsub_node_dev.itemids)])),
                {Retracted_Items, Publisher_Retracted_ItemIds} =
                    delete_old_items(Suffix,
                        _Publisher = {U,S,undefined},
                        NodeIdx,
                        _Notify_Retract = get_value(Node_Options,
                            'notify_retract', false),
                        Old_ItemIds, {[], {[], []}}),
                %%
                mnesia:write(table('pubsub_node', Suffix),
                    Pubsub_Node#pubsub_node_dev{
                        itemids = New_ItemIds
                    },
                    write),
                mnesia:write(table('pubsub_item', Suffix),
                    #pubsub_item_dev{
                        id       = {ItemId, NodeIdx},
                        nodeidx  = NodeIdx,
                        owners   = [{U,S,undefined}],
                        creation = {DateTime, {U,S,R}},
                        payload  = Payload,
                        options  = Item_Options
                    },
                    write),
            %%
            mnesia:write(Table_Pubsub_State,
                case Pubsub_State of
                    undefined ->
                        #pubsub_state_dev{
                            id      = {{U,S,undefined}, NodeIdx},
                            nodeidx = NodeIdx,
                            itemids = [ItemId]
                        };
                    _ ->
                        Pubsub_State#pubsub_state_dev{
                            itemids = [ItemId
                                | lists:foldl(fun
                                        (Publisher_Retracted_ItemId,
                                         Publisher_ItemIds) ->
                                             lists:delete(
                                                 Publisher_Retracted_ItemId,
                                                 Publisher_ItemIds)
                                  end,
                                      Pubsub_State#pubsub_state_dev.itemids,
                                          Publisher_Retracted_ItemIds)]
                        }
                end,
                write),
                Retracted_Items

    end,
    case get_value(Node_Options, 'send_last_published_item', 'never') of
        'never' ->
            ok;
        _Send_Last_Published_Item ->
            mnesia:write(table('pubsub_last_item', Suffix),
                #pubsub_last_item_dev{
                    nodeidx  = NodeIdx,
                    id       = ItemId,
                    owners   = [{U,S,undefined}],
                    creation = {DateTime, _Creator = {U,S,R}},
                    payload  = Payload,
                    options  = Item_Options
                },
                write)
    end,
    {ItemId, _Retracted_Items,
     _Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx, nodeidx)}.

%%
-spec(max_items/2 ::
(
  Max_Items   :: undefined | non_neg_integer(),
  New_ItemIds :: [ItemId::exmpp_pubsub:itemId()])
    -> ItemIds :: {New_ItemIds::[ItemId::exmpp_pubsub:itemId()],
                   Old_ItemIds::[ItemId::exmpp_pubsub:itemId()]}
).

max_items(undefined = _Max_Items, New_ItemIds) ->
    _ItemIds = {New_ItemIds, _Old_ItemIds = []};
max_items(0 = _Max_Items, New_ItemIds) ->
    _ItemIds = {_New_ItemIds = [], _Old_ItemIds = New_ItemIds};
max_items(Max_Items, New_ItemIds) ->
    _ItemIds = case Max_Items >= (Length_Items = length(New_ItemIds)) of
        true ->
            {New_ItemIds, _Old_ItemIds = []};
        false ->
            diff_items((Length_Items - Max_Items), _Count = 0, {New_ItemIds, []})
    end.

%%
-spec(diff_items/3 ::
(
  Diff_Items :: pos_integer(),
  Count      :: non_neg_integer(),
  ItemIds    :: {New_ItemIds::[ItemId::exmpp_pubsub:itemId()],
                 Old_ItemIds::[ItemId::exmpp_pubsub:itemId()]})
    -> ItemIds :: {New_ItemIds::[ItemId::exmpp_pubsub:itemId()],
                   Old_ItemIds::[ItemId::exmpp_pubsub:itemId()]}
).

diff_items(Diff_Items, _Count = Diff_Items, ItemIds) ->
    ItemIds;
diff_items(Diff_Items, Count, {[ItemId | New_ItemIds], Old_ItemIds}) ->
    diff_items(Diff_Items, Count + 1, {New_ItemIds, [ItemId | Old_ItemIds]}).


%%
-spec(delete_old_items/6 ::
(
  Suffix              :: atom(),
  Publisher           :: xmpp_jid:usr_bare(),
  NodeIdx             :: exmpp_pubsub:nodeIdx(),
  Node_Notify_Retract :: boolean(),
  ItemIds             :: [ItemId::exmpp_pubsub:itemId()],
  %%
  {Retracted_Items :: [Retracted_Item::{
     ItemId       :: exmpp_pubsub:itemId(),
     Item_Options :: [] | pubsub_options:options_item()
   }],
   %
   Publishers_Retracted_ItemIds :: {
       %%
       Entities_Retracted_ItemIds  :: [Entity_Retracted_ItemIds::{
           Entity  :: xmpp_jid:usr_bare(),
           ItemIds :: [ItemId::exmpp_pubsub:itemId()]
       }],
       %%
       Publisher_Retracted_ItemIds :: [ItemId::exmpp_pubsub:itemId()]
   }
  })
    -> {Retracted_Items :: [Retracted_Item::{
          ItemId       :: exmpp_pubsub:itemId(),
          Item_Options :: [] | pubsub_options:options_item()
        }],
        Publisher_Retracted_ItemIds :: [ItemId::exmpp_pubsub:itemId()]}
).

delete_old_items(Suffix, _Publisher, NodeIdx, _Notify_Retract, [] = _ItemIds,
  {Retracted_Items, {Entities_ItemIds, Publisher_ItemIds}}) ->
    Table_Pubsub_State = table('pubsub_state', Suffix),
    lists:foreach(fun
        ({Entity, Entity_ItemIds}) ->
            case mnesia:read(Table_Pubsub_State, {Entity, NodeIdx}, write) of
                [Pubsub_State] ->
                    mnesia:write(Table_Pubsub_State,
                        Pubsub_State#pubsub_state_dev{
                            itemids = lists:foldl(fun
                                (Retracted_ItemId, ItemIds) ->
                                    lists:delete(Retracted_ItemId, ItemIds)
                          end,
                              Pubsub_State#pubsub_state_dev.itemids,
                                    Entity_ItemIds)
                        },
                        write);
                     [] -> %% shouldn't happen
                        ok
            end
            %
    end, Entities_ItemIds),
    {Retracted_Items, Publisher_ItemIds};
%%
delete_old_items(Suffix, Publisher, NodeIdx, Notify_Retract, [ItemId | ItemIds],
  {Retracted_Items, Publishers_ItemIds}) ->
    Table_Pubsub_Item = table('pubsub_item', Suffix),
    delete_old_items(Suffix, Publisher, NodeIdx, Notify_Retract, ItemIds,
        case mnesia:read(Table_Pubsub_Item, {ItemId, NodeIdx}, write) of
            [Pubsub_Item] ->
                mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item, write),
                %% @TODO: Unregister 'pubsub#item_expire'
                {_Retracted_Items = case
                     get_value(Pubsub_Item#pubsub_item_dev.options,
                         'notify_retract', Notify_Retract)
                 of
                    true ->
                        [{ItemId, Pubsub_Item#pubsub_item_dev.options}
                        | Retracted_Items];
                    false ->
                        Retracted_Items
                 end,
                 %%
                 _Publishers_ItemIds = lists:foldl(fun
                     %%
                     (Item_Owner, {Entities_ItemIds, Publisher_ItemIds})
                       when Item_Owner == Publisher ->
                         {Entities_ItemIds,
                          [ItemId | Publisher_ItemIds]};
                     %%
                     (_Item_Owner = Entity,
                      {Entities_ItemIds, Publisher_ItemIds}) ->
                         {_Entities_ItemIds = case
                              lists:keyfind(Entity, 1, Entities_ItemIds)
                          of
                              {_Entity, Entity_ItemIds} ->
                                  lists:keyreplace(Entity, 1, Entities_ItemIds,
                                      {Entity, [ItemId | Entity_ItemIds]});
                            false ->
                                [{Entity, [ItemId]} | Entities_ItemIds]
                          end,
                          Publisher_ItemIds}
                 end, Publishers_ItemIds, Pubsub_Item#pubsub_item_dev.owners)};
            [] ->
                {Retracted_Items, Publishers_ItemIds}
        end).


%-- Retract_Item --%
-spec(retract_item/5 ::
(
  Suffix               :: atom(),
  Pubsub_Node          :: mod_pubsub_dev:pubsub_node(),
  Pubsub_State         :: mod_pubsub_dev:pubsub_state_owner()
                        | mod_pubsub_dev:pubsub_state_member()
                        | mod_pubsub_dev:pubsub_state_publish_only()
                        | mod_pubsub_dev:pubsub_state_publisher()
                        | mod_pubsub_dev:pubsub_state_none(),
  ItemId               :: exmpp_pubsub:itemId(),
  Adhoc_Notify_Retract :: undefined | boolean())
    -> {ok, undefined}
     %
     | {ok,
        Item_Options  :: [] | pubsub_options:options_item(),
        Pubsub_States :: mod_pubsub_dev:pubsub_states()}
    %%%
     | {error, 'forbidden'}
     | {error, 'item-not-found'}
).

retract_item(Suffix, Pubsub_Node,
  #pubsub_state_dev{id = {Entity, NodeIdx}} = Pubsub_State, ItemId,
  Adhoc_Notify_Retract) ->
    Table_Pubsub_Item = table('pubsub_item', Suffix),
    case mnesia:read(Table_Pubsub_Item, {ItemId, NodeIdx}, write) of
        [Pubsub_Item]
          when   Pubsub_State#pubsub_state_dev.affiliation == 'owner'
          orelse Pubsub_State#pubsub_state_dev.affiliation == 'publisher' ->
            mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item, write),
            Table_Pubsub_Last_Item = table('pubsub_last_item', Suffix),
            case mnesia:read(Table_Pubsub_Last_Item, NodeIdx, read) of
                [Pubsub_Last_Item]
                  when Pubsub_Last_Item#pubsub_last_item_dev.id == ItemId ->
                    mnesia:delete_object(Table_Pubsub_Last_Item,
                        Pubsub_Last_Item, write);
                _ ->
                    ok
            end,
            Table_Pubsub_State = table('pubsub_state', Suffix),
            case
                retract_item(NodeIdx, ItemId, Table_Pubsub_State, Entity,
                    _Item_Owners = Pubsub_Item#pubsub_item_dev.owners, false)
            of
                true ->
                    mnesia:write(Table_Pubsub_State,
                        Pubsub_State#pubsub_state_dev{
                            itemids = lists:delete(ItemId,
                                Pubsub_State#pubsub_state_dev.itemids)
                        },
                        write);
                false ->
                    ok
            end,
            mnesia:write(table('pubsub_node', Suffix),
                Pubsub_Node#pubsub_node_dev{
                    itemids = lists:delete(ItemId,
                        Pubsub_Node#pubsub_node_dev.itemids)
                },
                write),
            case
                Adhoc_Notify_Retract == true
                    orelse
                get_value(
                    {Pubsub_Node#pubsub_node_dev.options,
                     Pubsub_Item#pubsub_item_dev.options},
                     'notify_retract', false)
            of
                true ->
                    {ok,
                     _Item_Options = Pubsub_Item#pubsub_item_dev.options,
                     _Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx, nodeidx)};
                false ->
                    {ok, undefined}
            end;
        %%
        [#pubsub_item_dev{creation = {_DateTime, _Creator = Entity}} = Pubsub_Item] ->
            mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item, write),
            Table_Pubsub_Last_Item = table('pubsub_last_item', Suffix),
            case mnesia:read(Table_Pubsub_Last_Item, NodeIdx, read) of
                [Pubsub_Last_Item]
                  when Pubsub_Last_Item#pubsub_last_item_dev.id == ItemId ->
                    mnesia:delete_object(Table_Pubsub_Last_Item,
                        Pubsub_Last_Item, write);
                _ ->
                    ok
            end,
            Table_Pubsub_State = table('pubsub_state', Suffix),
            case
                retract_item(NodeIdx, ItemId, Table_Pubsub_State, Entity,
                    _Item_Owners = Pubsub_Item#pubsub_item_dev.owners, false)
            of
                true ->
                    mnesia:write(Table_Pubsub_State,
                        Pubsub_State#pubsub_state_dev{
                            itemids = lists:delete(ItemId,
                                Pubsub_State#pubsub_state_dev.itemids)
                        },
                        write);
                false ->
                    ok
            end,
            mnesia:write(table('pubsub_node', Suffix),
                Pubsub_Node#pubsub_node_dev{
                    itemids = lists:delete(ItemId,
                        Pubsub_Node#pubsub_node_dev.itemids)
                },
                write),
            case
                Adhoc_Notify_Retract == true
                    orelse
                get_value(
                    {Pubsub_Node#pubsub_node_dev.options,
                     Pubsub_Item#pubsub_item_dev.options},
                     'notify_retract', false)
            of
                true ->
                    {ok,
                     _Item_Options = Pubsub_Item#pubsub_item_dev.options,
                     _Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx, nodeidx)};
                false ->
                    {ok, undefined}
            end;
        [_Pubsub_Item] ->
            {error, 'forbidden'};
        %%
        [] ->
            {error, 'item-not-found'}
    end.


%%
-spec(retract_item/6 ::
(
  NodeIdx            :: exmpp_pubsub:nodeIdx(),
  ItemId             :: exmpp_pubsub:itemId(),
  Table_Pubsub_State :: atom(),
  Entity             :: xmpp_jid:usr_bare() | undefined,
  Item_Owners        :: [Entity::xmpp_jid:usr_bare(),...],
  Retract_ItemId     :: boolean())
    -> Retract_ItemId :: boolean()
).

retract_item(_NodeIdx, _ItemId, _Table_Pubsub_State, _Entity, [] = _Item_Owners,
  Retract_ItemId) ->
    Retract_ItemId;
%%
retract_item(NodeIdx, ItemId, Table_Pubsub_State, Entity,
  [_Item_Owner = Entity | Item_Owners], _Retract_ItemId) ->
    retract_item(NodeIdx, ItemId, Table_Pubsub_State, undefined, Item_Owners,
        true);
%%
retract_item(NodeIdx, ItemId, Table_Pubsub_State, _Entity,
  [_Item_Owner = Entity | Item_Owners], Retract_ItemId) ->
    case mnesia:read(Table_Pubsub_State, {Entity, NodeIdx}, write) of
        [Pubsub_State] ->
            mnesia:write(Table_Pubsub_State,
                Pubsub_State#pubsub_state_dev{
                    itemids = lists:delete(ItemId,
                        Pubsub_State#pubsub_state_dev.itemids)
                },
                write);
        [] ->
            ok
    end,
    retract_item(NodeIdx, ItemId, Table_Pubsub_State, _Entity, Item_Owners,
        Retract_ItemId).

%-- Subscribe_Node --%
-spec(subscribe_node/8 ::
(
  Suffix               :: atom(),
  Host                 :: xmpp_jid:raw_jid_component_bare(),
  Node_Options         :: pubsub_options:options_node(),
  Node_Owners          :: [Entity::xmpp_jid:usr_bare(),...],
  Pubsub_State         :: mod_pubsub_dev:pubsub_state(),
  Resource             :: undefined
                        | xmpp_jid:resource_jid()
                        | {'caps', xmpp_jid:resource_jid()},
  Subscription_Options :: [] | pubsub_options:options_subscription(),
  Pubsub_Features      :: exmpp_pubsub:pubsub_features())
    -> {result,
        Subscription_Subscribed :: exmpp_pubsub:subscription_subscribed(),
        Pubsub_Last_Item        :: undefined | mod_pubsub_dev:pubsub_last_item()}
     %
     | {result,
        Subscription_Pending :: exmpp_pubsub:subscription_pending(),
        Pubsub_Last_Item     :: undefined}
    %%%
     | {error, 'forbidden'}
     | {error, 'not-authorized', 'presence-subscription-required'}
     | {error, 'not-authorized', 'not-in-roster-group'}
     | {error, 'not-authorized', 'pending-subscription'}
     | {error, 'not-allowed',    'closed-node'}
).

subscribe_node(Suffix, Host, Node_Options, Node_Owners,
  #pubsub_state_dev{id = {{_U,S,_R} = Entity, _NodeIdx}} = Pubsub_State, Resource,
  Subscription_Options, Pubsub_Features) ->
    Affiliation = Pubsub_State#pubsub_state_dev.affiliation,
    Subscriptions = Pubsub_State#pubsub_state_dev.subscriptions,
    case
        options_on_subscribe_node(Host, Node_Options, Node_Owners, Entity,
            Resource, Affiliation, Subscriptions, Subscription_Options,
            Pubsub_Features)
    of
        %%
        {ok, 'new',
         {'pending', SubId, _Resource, _Subscription_Options} = Subscription} ->
            mnesia:write(table('pubsub_state', Suffix),
                Pubsub_State#pubsub_state_dev{
                    affiliation   = case Affiliation of
                        'none'      -> 'member';
                        Affiliation -> Affiliation
                    end,
                    subscriptions = [Subscription | Subscriptions]
                },
                write),
            Table_Pubsub_Subscription_Pending = table('pubsub_subscription_pending',
                Suffix),
            case
                mnesia:read(Table_Pubsub_Subscription_Pending,
                    Pubsub_State#pubsub_state_dev.id, write)
            of
                [] ->
                    mnesia:write(Table_Pubsub_Subscription_Pending,
                        #pubsub_subscription_pending{
                            id      = Pubsub_State#pubsub_state_dev.id,
                            nodeidx = Pubsub_State#pubsub_state_dev.nodeidx,
                            subids  = [SubId]
                        },
                        write);
                [Pubsub_Subscription_Pending] ->
                    mnesia:write(Table_Pubsub_Subscription_Pending,
                        Pubsub_Subscription_Pending#pubsub_subscription_pending{
                            subids = [SubId
                                | Pubsub_Subscription_Pending
                                      #pubsub_subscription_pending.subids]
                        },
                        write)
            end,
            {result, Subscription, _Pubsub_Last_Item = undefined};
        %%
        {ok, Type, Subscription} ->
            case Type of
                'new' ->
                    mnesia:write(table('pubsub_state', Suffix),
                        Pubsub_State#pubsub_state_dev{
                            affiliation   = case Affiliation of
                                'none'      -> 'member';
                                Affiliation -> Affiliation
                            end,
                            subscriptions = [Subscription | Subscriptions]
                        },
                        write);
                'old' ->
                    ok
            end,
            {result,
             Subscription,
             _Pubsub_Last_Item = case
                 (get_value(Subscription_Options, 'deliver', true) == true)
                          andalso
                 (get_value(Subscription_Options, 'show-values') =/= [])
                          andalso
                 (get_value(Node_Options, 'send_last_published_item', 'never')
                      =/= 'never')
             of
                 true ->
                     case
                         mnesia:read(table('pubsub_last_item', Suffix),
                             Pubsub_State#pubsub_state_dev.nodeidx,
                             read)
                     of
                         []                 -> undefined;
                         [Pubsub_Last_Item] -> Pubsub_Last_Item
                     end;
             false ->
                 undefined
             end};
        Error ->
            Error
    end.

%%
-spec(options_on_subscribe_node/9 ::
(
  Host                 :: xmpp_jid:raw_jid_component_bare(),
  Node_Options         :: pubsub_options:options_node(),
  Node_Owners          :: [Entity::xmpp_jid:usr_bare(),...],
  Entity               :: xmpp_jid:usr_bare(),
  Resource             :: undefined
                        | xmpp_jid:resource_jid()
                        | {'caps', xmpp_jid:resource_jid()},
  Affiliation          :: exmpp_pubsub:affiliation(),
  Subscriptions        :: [] | exmpp_pubsub:subscriptions(),
  Subscription_Options :: [] | pubsub_options:options_subscription(),
  Pubsub_Features      :: exmpp_pubsub:pubsub_features())
    -> {ok,
        Type         :: 'new' | 'old',
        Subscription :: exmpp_pubsub:subscription_subscribed()}
     %
     | {ok,
        Type         :: 'new',
        Subscription :: exmpp_pubsub:subscription_pending()}
    %%%
     | {error, 'forbidden'}
     | {error, 'not-authorized', 'presence-subscription-required'}
     | {error, 'not-authorized', 'not-in-roster-group'}
     | {error, 'not-authorized', 'pending-subscription'}
     | {error, 'not-allowed',    'closed-node'}
).

options_on_subscribe_node(Host, Node_Options, Node_Owners, Entity,
  Resource, Affiliation, Subscriptions, Subscription_Options, Pubsub_Features) ->
    options_on_subscribe_node(get_option(Node_Options, 'subscribe'), Host,
        Node_Options, Node_Owners, Entity, Resource, Affiliation, Subscriptions,
        Subscription_Options,
        _Multi_Subscribe = lists:member(<<"multi-subscribe">>, Pubsub_Features)).

%%
-spec(options_on_subscribe_node/10 ::
(
  Option               :: pubsub_options:option_node_access_model()
                        | pubsub_options:option_node_subscribe(),
  Host                 :: xmpp_jid:raw_jid_component_bare(),
  Node_Options         :: pubsub_options:options_node(),
  Node_Owners          :: [Entity::xmpp_jid:usr_bare(),...],
  Entity               :: xmpp_jid:usr_bare(),
  Resource             :: undefined
                        | xmpp_jid:resource_jid()
                        | {'caps', xmpp_jid:resource_jid()},
  Affiliation          :: exmpp_pubsub:affiliation(),
  Subscriptions        :: [] | exmpp_pubsub:subscriptions(),
  Subscription_Options :: [] | pubsub_options:options_subscription(),
  Multi_Subscribe      :: boolean())
    -> {ok,
        Type         :: 'new' | 'old',
        Subscription :: exmpp_pubsub:subscription_subscribed()}
     %
     | {ok,
        Type         :: 'new',
        Subscription :: exmpp_pubsub:subscription_pending()}
    %%%
     | {error, 'forbidden'}
     | {error, 'not-authorized', 'presence-subscription-required'}
     | {error, 'not-authorized', 'not-in-roster-group'}
     | {error, 'not-authorized', 'pending-subscription'}
     | {error, 'not-allowed',    'closed-node'}
).

options_on_subscribe_node({'subscribe', Subscribe}, _Host, _Node_Options,
  _Node_Owners, _Entity, _Resource, Affiliation, _Subscriptions,
  _Subscription_Options, _Multi_Subscribe)
  when   Subscribe   == false
  orelse Affiliation == 'outcast'
  orelse Affiliation == 'publish-only' ->
    {error, 'forbidden'};
%%
options_on_subscribe_node({'subscribe', true}, Host, Node_Options,
  Node_Owners, Entity, Resource, Affiliation, Subscriptions,
  Subscription_Options, Multi_Subscribe) ->
    options_on_subscribe_node(get_option(Node_Options, 'access_model'), Host,
        Node_Options, Node_Owners, Entity, Resource, Affiliation, Subscriptions,
        Subscription_Options, Multi_Subscribe);

options_on_subscribe_node({'access_model', open}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, _Affiliation, Subscriptions,
  Subscription_Options, false = _Multi_Subscribe) ->
    case lists:keyfind(Resource, 3, Subscriptions) of
        {_Resource, Subscription} ->
            {ok, 'old', Subscription};
        false ->
            {ok,
             'new',
             exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
    end;
%%
options_on_subscribe_node({'access_model', open}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, _Affiliation, _Subscriptions,
  Subscription_Options, true = _Multi_Subscribe) ->
    {ok, 'new', exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)};
%%
options_on_subscribe_node({'access_model', presence}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, Affiliation, Subscriptions,
  Subscription_Options, false = _Multi_Subscribe)
  when   Affiliation == 'owner'
  orelse Affiliation == 'publisher'
  orelse Affiliation == 'member' ->
    case lists:keyfind(Resource, 3, Subscriptions) of
        {_Resource, Subscription} ->
            {ok, 'old', Subscription};
        false ->
            {ok,
             'new',
             exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
    end;
%%
options_on_subscribe_node({'access_model', presence}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, Affiliation, _Subscriptions,
  Subscription_Options, true = _Multi_Subscribe)
  when   Affiliation == 'owner'
  orelse Affiliation == 'publisher'
  orelse Affiliation == 'member' ->
    {ok,
     'new',
     exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)};
%%
options_on_subscribe_node({'access_model', presence}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, Affiliation, Subscriptions,
  Subscription_Options, false = _Multi_Subscribe)
  when   Affiliation == 'owner'
  orelse Affiliation == 'publisher'
  orelse Affiliation == 'member' ->
    case lists:keyfind(Resource, 3, Subscriptions) of
        {_Resource, Subscription} ->
            {ok, 'old', Subscription};
        false ->
            {ok,
             'new',
             exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
    end;
%%
options_on_subscribe_node({'access_model', presence}, Host, _Node_Options,
  Node_Owners, Entity, Resource, _Affiliation, _Subscriptions,
  Subscription_Options, _Multi_Subscribe) ->
    case is_contact_subscribed_to_node_owners(Host, Entity, Node_Owners) of
        false ->
            {error, 'not-authorized', 'presence-subscription-required'};
        _Node_Owner ->
            {ok,
             'new',
             exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
    end;
%%
options_on_subscribe_node({'access_model', roster}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, Affiliation, _Subscriptions,
  Subscription_Options, true = _Multi_Subscribe)
  when   Affiliation == 'owner'
  orelse Affiliation == 'publisher'
  orelse Affiliation == 'member' ->
    {ok,
     'new',
     exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)};
%%
options_on_subscribe_node({'access_model', roster}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, Affiliation, Subscriptions,
  Subscription_Options, false = _Multi_Subscribe)
  when   Affiliation == 'owner'
  orelse Affiliation == 'publisher'
  orelse Affiliation == 'member' ->
    case lists:keyfind(Resource, 3, Subscriptions) of
        {_Resource, Subscription} ->
            {ok, 'old', Subscription};
        false ->
            {ok,
             'new',
             exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
    end;
%%
options_on_subscribe_node({'access_model', roster}, _Host, Node_Options,
  _Node_Owners, Entity, Resource, _Affiliation, _Subscriptions,
  Subscription_Options, _Multi_Subscribe) ->
    case
        is_contact_in_allowed_roster_groups(Entity,
            get_value(Node_Options, 'roster_groups_allowed', []))
    of
        false ->
            {error, 'not-authorized', 'not-in-roster-group'};
        {_Node_Owner, _Roster_Group} ->
            {ok,
             'new',
             exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
    end;
%%
options_on_subscribe_node({'access_model', authorize}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, Affiliation, _Subscriptions,
  Subscription_Options, true = _Multi_Subscribe)
  when   Affiliation == 'owner'
  orelse Affiliation == 'publisher'
  orelse Affiliation == 'member' ->
    {ok,
     'new',
     exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)};
%%
options_on_subscribe_node({'access_model', authorize}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, Affiliation, Subscriptions,
  Subscription_Options, false = _Multi_Subscribe)
  when   Affiliation == 'owner'
  orelse Affiliation == 'publisher'
  orelse Affiliation == 'member' ->
    case lists:keyfind(Resource, 3, Subscriptions) of
        {_Resource, Subscription} ->
            {ok, 'old', Subscription};
        false ->
            {ok,
             'new',
             exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
    end;
%%
options_on_subscribe_node({'access_model', authorize}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, _Affiliation, Subscriptions,
  Subscription_Options, false = _Multi_Subscribe) ->
    case lists:keyfind(Resource, 3, Subscriptions) of
        {_Resource, _Subscription} ->
            {error, 'not-authorized', 'pending-subscription'};
        false ->
            {ok,
             'new',
             exmpp_pubsub:subscription_pending(Resource, Subscription_Options)}
    end;
%%
options_on_subscribe_node({'access_model', whitelist}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, Affiliation, _Subscriptions,
  Subscription_Options,  true = _Multi_Subscribe)
  when   Affiliation == 'owner'
  orelse Affiliation == 'publisher'
  orelse Affiliation == 'member' ->
    {ok,
     'new',
     exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)};
%%
options_on_subscribe_node({'access_model', whitelist}, _Host, _Node_Options,
  _Node_Owners, _Entity, Resource, Affiliation, Subscriptions,
  Subscription_Options, false = _Multi_Subscribe)
  when   Affiliation == 'owner'
  orelse Affiliation == 'publisher'
  orelse Affiliation == 'member' ->
    case lists:keyfind(Resource, 3, Subscriptions) of
        {_Resource, Subscription} ->
            {ok, 'old', Subscription};
        false ->
            {ok,
             'new',
             exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
    end;
%%
options_on_subscribe_node({'access_model', whitelist}, _Host, _Node_Options,
  _Node_Owners, _Entity, _Resource, _Affiliation, _Subscriptions,
  _Subscription_Options, _Multi_Subscribe) ->
    {error, 'not-allowed', 'closed-node'}.


%-- Unsubscribe_Node --%
-spec(unsubscribe_node/6 ::
(
  Suffix            :: atom(),
  Host              :: xmpp_jid:raw_jid_component_bare(),
  Node_Access_Model :: pubsub_options:access_model(),
  Pubsub_State      :: mod_pubsub_dev:pubsub_state_member()
                     | mod_pubsub_dev:pubsub_state_outcast()
                     | mod_pubsub_dev:pubsub_state_owner()
                     | mod_pubsub_dev:pubsub_state_publisher(),
  Resource          :: undefined
                     | xmpp_jid:resource_jid()
                     | {'caps', xmpp_jid:resource_jid()},
  SubId             :: undefined | exmpp_pubsub:subId())
    -> {ok,
        Resource :: undefined
                  | xmpp_jid:resource_jid()
                  | {'caps', xmpp_jid:resource_jid()},
        SubId    :: exmpp_pubsub:subId()}
    %%%
     | {error, 'unexpected',     'not-subscribed'}
     | {error, 'not-acceptable', 'invalid-subid'}
     | {error, 'bad-request',    'subid-required'}
     | {error, 'not-acceptable', 'invalid-subid'}
).

unsubscribe_node(Suffix, Host, Node_Access_Model,
  #pubsub_state_dev{subscriptions = [{Subscription_State, SubId, Resource, _}]}
  = Pubsub_State, Resource, _SubId)
  when _SubId == undefined orelse _SubId == SubId ->
    mnesia:write(table('pubsub_state', Suffix),
        Pubsub_State#pubsub_state_dev{
            subscriptions = []
        },
        write),
    %% unregister pending subscription
    case Subscription_State of
        'pending' ->
            unregister_pending_subscription(Suffix,
                Pubsub_State#pubsub_state_dev.id, SubId);
        _ ->
            ok
    end,
    case Node_Access_Model of
        'roster' ->
            ok;
        _ ->
            ok
    end,
    {ok, Resource, SubId};
%%
unsubscribe_node(Suffix, Host, Node_Access_Model,
  #pubsub_state_dev{subscriptions = [{_Subscription_State, SubId, _Resource, _}]}
  = Pubsub_State, Resource, SubId) ->
    {error, 'unexpected', 'not-subscribed'};
%%
unsubscribe_node(Suffix, Host, Node_Access_Model,
  #pubsub_state_dev{subscriptions = [{_Subscription_State, _SubId, Resource, _}]}
  = Pubsub_State, Resource, SubId) ->
    {error, 'not-acceptable', 'invalid-subid'};
%%
unsubscribe_node(Suffix, Host, Node_Access_Model, Pubsub_State, Resource,
  undefined = _SubId) ->
    case lists:keytake(Resource, 3, Pubsub_State#pubsub_state_dev.subscriptions) of
        {value,
         {Subscription_State, SubId, Resource, _} = Subscription, Subscriptions} ->
            case lists:keymember(Resource, 3, Subscriptions) of
                false ->
                    mnesia:write(table('pubsub_state', Suffix),
                        Pubsub_State#pubsub_state_dev{
                            subscriptions = Subscriptions
                        },
                        write),
                    %% unregister pending subscription
                    case Subscription_State of
                        'pending' ->
                            unregister_pending_subscription(Suffix,
                                Pubsub_State#pubsub_state_dev.id, SubId);
                        _ ->
                            ok
                    end,
                    case Node_Access_Model of
                        'roster' ->
                            ok;
                        _ ->
                            ok
                    end,
                    %% TODO : unregister 'pubsub#tempsub'
                    {ok, Resource, SubId};
                true ->
                    {error, 'bad-request', 'subid-required'}
            end;
        false ->
            {error, 'unexpected', 'not-subscribed'}
    end;
%%
unsubscribe_node(Suffix, Host, Node_Access_Model, Pubsub_State, Resource, SubId) ->
    case lists:keytake(SubId, 2, Pubsub_State#pubsub_state_dev.subscriptions) of
        {value,
         {Subscription_State, SubId, Resource, _} = Subscription, Subscriptions} ->
            mnesia:write(table('pubsub_state', Suffix),
                Pubsub_State#pubsub_state_dev{
                    subscriptions = Subscriptions
                },
                write),
                %% unregister pending subscription
                case Subscription_State of
                    'pending' ->
                        unregister_pending_subscription(Suffix,
                            Pubsub_State#pubsub_state_dev.id, SubId);
                    _ ->
                        ok
                end,
                case Node_Access_Model of
                    'roster' ->
                        ok;
                    _ ->
                        ok
                end,
                {ok, Resource, SubId};
        {value, {_Subscription_State, SubId, _Resource, _} = Subscription, _} ->
            {error, 'unexpected', 'not-subscribed'};
        false ->
            {error, 'not-acceptable', 'invalid-subid'}
    end.

%%
-spec(register_pending_subscription/3 ::
(
  Suffix  :: atom(),
  StateId :: {Entity::xmpp_jid:usr_bare(), NodeIdx::exmpp_pubsub:nodeIdx()},
  SubId   :: exmpp_pubsub:subId())
    -> 'ok'
).

register_pending_subscription(Suffix, {Entity, NodeIdx} = _StateId, SubId) ->
    Table_Pubsub_Subscription_Pending = table('pubsub_subscription_pending', Suffix),
    case mnesia:read(Table_Pubsub_Subscription_Pending, {Entity, NodeIdx}, write) of
        [] ->
            mnesia:write(Table_Pubsub_Subscription_Pending,
                #pubsub_subscription_pending{
                    id      = {Entity, NodeIdx},
                    nodeidx = NodeIdx,
                    subids  = [SubId]
                },
                write);
        [Pubsub_Subscription_Pending] ->
            mnesia:write(Table_Pubsub_Subscription_Pending,
                Pubsub_Subscription_Pending#pubsub_subscription_pending{
                    subids = [SubId
                        | Pubsub_Subscription_Pending
                              #pubsub_subscription_pending.subids]
                },
                write)
    end.

%%
-spec(unregister_pending_subscription/3 ::
(
  Suffix  :: atom(),
  StateId :: {Entity::xmpp_jid:usr_bare(), NodeIdx::exmpp_pubsub:nodeIdx()},
  SubId   :: exmpp_pubsub:subId())
    -> 'ok'
).

unregister_pending_subscription(Suffix, StateId, SubId) ->
    Table_Pubsub_Subscription_Pending = table('pubsub_subscription_pending', Suffix),
    case mnesia:read(Table_Pubsub_Subscription_Pending, StateId, write) of
        %%
        [#pubsub_subscription_pending{subids = [SubId]} = Pubsub_Subscription_Pending] ->
            mnesia:delete_object(Table_Pubsub_Subscription_Pending,
                Pubsub_Subscription_Pending, write);
        %%
        [Pubsub_Subscription_Pending] ->
            mnesia:write(Table_Pubsub_Subscription_Pending,
                Pubsub_Subscription_Pending#pubsub_subscription_pending{
                    subids = lists:delete(SubId,
                        Pubsub_Subscription_Pending#pubsub_subscription_pending.subids)
                    },
                write);
        [] ->
            ok
    end.

%-- Set_Configure_Subscription --%
-spec(set_configure_subscription/5 ::
(
  Suffix               :: atom(),
  Pubsub_State         :: mod_pubsub_dev:pubsub_state_member()
                        | mod_pubsub_dev:pubsub_state_owner()
                        | mod_pubsub_dev:pubsub_state_publisher(),
  SubId                :: undefined | exmpp_pubsub:subId(),
  Resource             :: undefined
                        | xmpp_jid:resource_jid()
                        | {'caps', xmpp_jid:resource_jid()},
  Subscription_Options :: pubsub_options:options_subscription())
    -> 'ok'
    %%%
     | {error, 'unexpected-request', 'not-subscribed'}
     | {error, 'bad-request',        'subid-required'}
     | {error, 'forbidden'}
     | {error, 'not-acceptable',     'invalid-subid'}
).

set_configure_subscription(Suffix, Pubsub_State, undefined = _SubId, Resource,
  Subscription_Options) ->
    case
        lists:keytake(Resource, 3, Pubsub_State#pubsub_state_dev.subscriptions)
    of
        {value, {Subscription_State, SubId, Resource, _Subscription_Options},
         Subscriptions} ->
            case lists:keymember(Resource, 3, Subscriptions) of
                false
                  when Subscription_State == 'pending' ->
                    {error, 'forbidden'};
                false ->
                    mnesia:write(table('pubsub_state', Suffix),
                        Pubsub_State#pubsub_state_dev{
                            subscriptions = [
                                {Subscription_State, SubId, Resource,
                                 Subscription_Options}
                                | Subscriptions]
                        },
                        write),
                    'ok';
                true ->
                    {error, 'bad-request', 'subid-required'}
            end;
         false ->
            {error, 'unexpected-request', 'not-subscribed'}
    end;
%%
set_configure_subscription(Suffix, Pubsub_State, SubId, Resource,
  Subscription_Options) ->
    case lists:keytake(SubId, 2, Pubsub_State#pubsub_state_dev.subscriptions) of
        {value, {'pending', SubId, Resource, _Subscription_Options},
         _Subscriptions} ->
            {error, 'forbidden'};
        {value, {Subscription_State, SubId, Resource, _Subscription_Options},
         Subscriptions} ->
            mnesia:write(table('pubsub_state', Suffix),
                Pubsub_State#pubsub_state_dev{
                    subscriptions = [
                        {Subscription_State, SubId, Resource,
                            Subscription_Options}
                        | Subscriptions]
                },
                write),
                'ok';
        {value, {_Subscription_State, SubId, _Resource, _Subscription_Options},
         _Subscriptions} ->
            {error, 'unexpected-request', 'not-subscribed'};
        false ->
            case
                lists:keytake(Resource, 3,
                    Pubsub_State#pubsub_state_dev.subscriptions)
            of
                {value, {'pending', _SubId, Resource, _Subscription_Options},
                 _Subscriptions} ->
                    {error, 'forbidden'};
                {value, {_Subscription_State, _SubId, _Resource, _Subscription_Options},
                 _Subscriptions} ->
                    {error, 'not-acceptable', 'invalid-subid'};
                false ->
                    {error, 'unexpected-request', 'not-subscribed'}
            end
    end.

%-- Get_Items --%
-spec(get_items/5 ::
(
  Suffix            :: pubsub_db_mnesia:table(),
  Host              :: xmpp_jid:raw_jid_component_bare(),
  Node_Parameters   :: {NodeIdx           :: exmpp_pubsub:nodeIdx(),
                        Node_Owners       :: mod_pubsub_dev:node_owners(),
                        Node_ItemIds      :: [] | exmpp_pubsub:itemIds(),
                        Node_Access_Model :: pubsub_options:access_model(),
                        Node_Groups       :: pubsub_options:rosters_groups_allowed()},
  %%
  Entity_Parameters :: {Entity      :: xmpp_jid:usr_bare(),
                        Affiliation :: exmpp_pubsub:affiliation(),
                        Access      :: undefined | 'pending' | 'roster' | 'presence' | 'authorize'},
  %%
  Criteria          :: {Max_Items :: non_neg_integer(),
                        ItemIds   :: undefined,
                        _SubId    :: exmpp_pubsub:subId()}
                     | {Max_Items :: undefined,
                        ItemIds   :: exmpp_pubsub:itemIds(),
                        _SubId    :: exmpp_pubsub:subId()})
    -> {ok,
        Pubsub_Items :: [] | mod_pubsub_dev:pubsub_items(),
        Cache        :: {Presence_Cache :: undefined,
                         Groups_Cache   :: undefined}}
     %
     | {ok,
        Pubsub_Items :: [] | mod_pubsub_dev:pubsub_items(),
        Cache        :: {Presence_Cache :: true,
                         Groups_Cache   :: undefined}}
     %
     | {ok,
        Pubsub_Items :: [] | mod_pubsub_dev:pubsub_items(),
        Cache        :: {Presence_Cache :: undefined,
                         Groups_Cache   :: [{Node_Owner :: xmpp_jid:usr_bare(),
                                             Groups     :: [Group::binary()]}]}}
    %%%
     | {error, 'forbidden'}
     | {error, 'not-authorized', 'presence-subscription-required'}
     | {error, 'not-authorized', 'not-in-roster-group'}
     | {error, 'not-allowed',    'closed-node'}
).

get_items(_Suffix, _Host, _Node_Parameters, {_Entity, Affiliation, Access}, _Criteria)
  when   Affiliation == 'outcast'
  orelse Affiliation == 'publish-only'
  orelse Access      == 'pending' ->
    {error, 'forbidden'};
%%
get_items(Suffix, _Host,
  {NodeIdx, _Node_Owners, Node_ItemIds, Node_Access_Model, _Node_Groups},
  {_Entity, Affiliation, Access}, {Max_Items, ItemIds, _SubId})
  when   Affiliation        == 'owner'
  %
  orelse Affiliation        == 'publisher'
  %
  orelse Affiliation        == 'member'
  %
  orelse Node_Access_Model  == 'open'
  %
  orelse (Node_Access_Model == 'presence'
      andalso
          Access == 'presence'
              orelse Access == 'roster')
  %
  orelse (Node_Access_Model == 'roster'
      andalso
          Access == 'roster')
  %
  orelse (Node_Access_Model == 'authorize'
      andalso
          Access == 'authorize') ->
    {ok,
     _Pusbub_Items = get_items(Suffix, NodeIdx,
         get_max_itemids(Max_Items, ItemIds, Node_ItemIds)),
     _Cache = {undefined, undefined}};
%
get_items(Suffix, Host,
  {NodeIdx, Node_Owners, Node_ItemIds, 'presence' = _Node_Access_Model, _Node_Groups},
  {Entity, _Affiliation, _Access}, {Max_Items, ItemIds, _SubId}) ->
    case is_contact_subscribed_to_node_owners(Host, Entity, Node_Owners) of
        false ->
            {error, 'not-authorized', 'presence-subscription-required'};
        Node_Owner ->
            {ok,
             _Pusbub_Items = get_items(Suffix, NodeIdx,
                 get_max_itemids(Max_Items, ItemIds, Node_ItemIds)),
             _Cache = {_Presence_Cache = true, _Groups_Cache = undefined}}
    end;
%%
get_items(Suffix, _Host,
  {NodeIdx, _Node_Owners, Node_ItemIds, 'roster' = _Node_Access_Model, Node_Groups},
  {Entity, _Affiliation, _Access}, {Max_Items, ItemIds, _SubId}) ->
    case is_contact_in_allowed_roster_groups(Entity, Node_Groups) of
        {Node_Owner, Roster_Group} ->
            {ok,
             _Pusbub_Items = get_items(Suffix, NodeIdx,
                 get_max_itemids(Max_Items, ItemIds, Node_ItemIds)),
             _Cache = {
                 _Presence_Cache = undefined,
                 _Groups_Cache = [{Node_Owner, [Roster_Group]}]
             }
            };
        false ->
            {error, 'not-authorized', 'not-in-roster-group'}
    end;
%%
get_items(_Suffix, _Host,
  {_NodeIdx, _Node_Owners, _Node_ItemIds, 'authorize' = _Node_Access_Model, _Node_Groups},
  _Entity_Parameters, _Criteria) ->
    {error, 'not-allowed', 'closed-node'};
%%
get_items(_Suffix, _Host, _Node_Parameters, _Entity_Parameters, _Criteria) ->
    {error, 'forbidden'}.

%%
-spec(get_max_itemids/3 ::
(
  Max_Items    :: undefined | non_neg_integer(),
  ItemIds      :: [] | exmpp_pubsub:itemIds(),
  Node_ItemIds :: [] | exmpp_pubsub:itemIds())
    -> Max_ItemIds :: undefined | [] | exmpp_pubsub:itemIds()
).

get_max_itemids(undefined = _Max_Items, [] = _ItemIds, _Node_ItemIds) ->
    _Max_ItemIds = undefined;
%%
get_max_itemids(undefined = _Max_Items, ItemIds, Node_ItemIds) ->
    _Max_ItemIds = lists:filter(fun
        (ItemId) ->
            lists:member(ItemId, Node_ItemIds)
    end, ItemIds);
%%
get_max_itemids(Max_Items, undefined = _ItemIds, Node_ItemIds) ->
    _Max_ItemIds = get_max_itemids(Max_Items, [], Node_ItemIds);
%%
get_max_itemids(_Max_Items, ItemIds, _Node_ItemIds)
  when _Max_Items == 0 orelse _Node_ItemIds == [] ->
    _Max_ItemIds = lists:reverse(ItemIds);
%%
get_max_itemids(Max_Items, ItemIds, [ItemId | Node_ItemIds]) ->
    get_max_itemids(Max_Items - 1, [ItemId | ItemIds], Node_ItemIds).

%%
-spec(get_items/3 ::
(
  Suffix  :: pubsub_db_mnesia:suffix(),
  NodeIdx :: exmpp_pubsub:nodeIdx(),
  ItemIds :: undefined | [] | exmpp_pubsub:itemIds())
    -> Pubsub_Items :: [] | mod_pubsub_dev:pubsub_items()
).

get_items(Suffix, NodeIdx, undefined = _ItemIds) ->
    _Pubsub_Items = mnesia:index_read(table('pubsub_item', Suffix), NodeIdx, nodeidx);
%%
get_items(Suffix, NodeIdx, ItemIds) ->
    Table_Pubsub_Item = table('pubsub_item', Suffix),
    _Pubsub_Items = lists:foldl(fun
        (ItemId, Pubsub_Items) ->
            case
                mnesia:index_match_object(Table_Pubsub_Item,
                    #pubsub_item_dev{
                        id      = {ItemId, NodeIdx},
                        nodeidx = NodeIdx,
                        _       = '_'
                    },
                    nodeidx,
                    read)
            of
                [Pubsub_Item] -> [Pubsub_Item | Pubsub_Items];
                _             -> Pubsub_Items
            end
    end, [], ItemIds).