function [NewEvents] = action(event, log_file)

% debug:
% TTL is determined at network layer only
% one way transmission received, reverse transmission fails, why?
    % mainly because randomness in the 'shadowing' model: solved...same distance generates same random number
    % friis model works fine
    % tworay model is mostly the same as friis because crossover distance = 100 m
    % freq should be 2.4G instead of 2.4M, white_noise_variance is changed correspondingly
% Duplicated packets due to early time out and retransmission: this is ok, just provide a larger timeout
% queue waiting problem: net_queue is actually always empty, all NET packets stack at mac_queue
    % mac_queue is accompanied by mac_status
% Question 1: how to decide the priority of broadcast, unicast transmission and receptioin?

% to add virtual carrier sense: done
% to add RTS-CTS: done
% to add ad hoc routing: done
% to add application layer actions:
% to add figures or animations to show network and traffic change: not critical

global adebug bdebug;
global Gt Gr freq L ht hr pathLossExp std_db d0 rmodel;
global cs_threshold white_noise_variance rv_threshold rv_threshold_delta;
global slot_time CW_min CW_max turnaround_time max_retries SIFS DIFS cca_time basic_rate default_power;
global max_size_mac_body size_mac_header size_rts size_cts size_ack size_plcp;
global n node Event_list;
global packet_id retransmit pending_id mac_queue backoff_attmpt backoff_counter backoff_attempt;
global nav;
global ack_tx_time cts_tx_time rts_tx_time;
global default_rate default_ttl;
global size_rreq size_rrep;
global rreq_timeout net_queue net_pending net_max_retries;
global rrep_table;  % id, route, metric
global bcast_table;
global mac_status;
global adebug bdebug cdebug ddebug;
global rreq_out rreq_in rreq_forward;
global rreq_out_crosslayer rreq_in_crosslayer rreq_forward_crosslayer;
global rrep_out rrep_in rrep_forward;
global rrep_out_crosslayer rrep_in_crosslayer rrep_forward_crosslayer rrep_destination_crosslayer;

NewEvents = [];

switch event.type   
    case 'send_phy'
        t = event.instant;
        i = event.node;
        j = event.pkt.rv;
        if adebug, disp(['send_phy at time ' num2str(t) ' node ' num2str(i) ' will send a packet to node ' num2str(j)]); end
        txtime = tx_time(event.pkt);
        if node(i, 4) == 0 & (nav(i).start > (t+txtime) | nav(i).end < t) % idle and no nav
            node(i, 3) = event.pkt.power;
            node(i, 4) = 1; % switch to transmit mode, assume turnaround time is zero
            % set up the receiver
            if j == 0   % broadcast from node i
                for k=1:n
                    % due to broadcast nature in wireless channel, every idle node may capture/sense this transmission
                    if node(k, 4)~=0 | k==i, continue; end
                    if overlap(t, t+txtime, nav(k).start, nav(k).end), continue; end
                    node(k, 4) = 2; % receiver switches to receiving mode
                    newevent = event;
                    newevent.instant = t + txtime;
                    newevent.type = 'recv_phy';
                    newevent.node = k;
                    NewEvents = [NewEvents; newevent]; clear newevent;
                end
                % when there is no node to receive this broadcast, still send it.
                % because I do not know if any node will respond, but actually node node will respond.
%                 if length(NewEvents) <= 0
%                     if ddebug, disp(['send_phy: node ' num2str(i) ' broadcasts to no nodes']); end
%                     newevent = event;
%                     newevent.instant = t;
%                     newevent.type = 'send_phy_finish';
%                     newevent.node = i;
%                     NewEvents = [NewEvents; newevent]; clear newevent;
%                     return;
%                 end
            else    % unicast from i to j
                if node(j, 4) ~= 0 | overlap(t, t+txtime, nav(j).start, nav(j).end)
                    if ddebug, disp(['send_phy: receiving node ' num2str(j) ' is not ready to receive from node ' num2str(i)]); end
                    % At physical layer, I cannot synchronize with the receiver, so I know I do not need to actually transmit?
                    % We sill transmit this packet, but no actual reception.
                    %                     newevent = event;
                    %                     newevent.instant = t;
                    %                     newevent.type = 'send_phy_finish';
                    %                     newevent.node = i;
                    %                     NewEvents = [NewEvents; newevent]; clear newevent;
                    %                     return;
                else
                    node(j, 4) = 2; % receiver is switched to receiving mode
                    newevent = event;
                    newevent.instant = t + txtime;
                    newevent.type = 'recv_phy';
                    newevent.node = j;
                    NewEvents = [NewEvents; newevent]; clear newevent;
                end
                for k=1:n
                    % due to broadcast nature in wireless channel, every idle node may capture/sense this transmission
                    if node(k, 4)~=0 | k==i | k==j, continue; end
                    if overlap(t, t+txtime, nav(k).start, nav(k).end), continue; end
                    node(k, 4) = 2; % receiver switches to receiving mode
                    newevent = event;
                    newevent.instant = t + txtime;
                    newevent.type = 'recv_phy';
                    newevent.node = k;
                    NewEvents = [NewEvents; newevent]; clear newevent;
                end
            end
            % setup the transmitter
            newevent = event;
            newevent.instant = t + txtime + eps;
            newevent.type = 'send_phy_finish';
            newevent.node = i;
            NewEvents = [NewEvents; newevent]; clear newevent;
            if strcmp(event.pkt.type, 'rts')
                % set timeout timer for RTS
                newevent = event;
                newevent.instant = t + (txtime + SIFS + cts_tx_time) * 2;   % question: how to choose this timeout limit?
                newevent.type = 'timeout_rts';
                newevent.node = i;
                NewEvents = [NewEvents; newevent]; clear newevent;
                if retransmit(i) <= 0 & pending_id(i) > 0
                    error(['send_phy: node ' num2str(i) ' there is already a pending packet, cannot send a new RTS packet']);
                end
                pending_id(i) = event.pkt.id;
            end
            if strcmp(event.pkt.type, 'data') & j ~= 0
                % set timeout timer for DATA
                newevent = event;
                newevent.instant = t + (txtime + SIFS + ack_tx_time) * 2;   % double check
                newevent.type = 'timeout_data';
                newevent.node = i;
                NewEvents = [NewEvents; newevent]; clear newevent;
                if retransmit(i) <= 0 & pending_id(i) > 0
                    error(['send_phy: node ' num2str(i) ' there is already a pending packet, cannot send a new DATA packet']);
                end
                pending_id(i) = event.pkt.id;
            end
        else    % radio hardware is not idle or nav block
            if adebug, disp(['send_phy at time ' num2str(t) ' node ' num2str(i) ' is not ready to send a packet to node ' num2str(j)]); end
            if adebug, disp(['--- node(i, 4)=' num2str(node(i, 4)) 'nav.start=' num2str(nav(i).start) 'nav.end=' num2str(nav(i).end)]); end
            % Since the node status is already checked at MAC layer, it must be due to NAV virtual carrier sense
            % I am a hiddent node: physical carrier sense is okay, but blocked by virtual carrier sense
            % I should go back to MAC and try later.
            newevent = event;
            newevent.instant = t + cca_time;
            newevent.type = 'wait_for_channel';
            newevent.node = i;
            NewEvents = [NewEvents; newevent]; clear newevent;
            % Drop the packet, and try next MAC packet if any
%             if ~isempty(mac_queue(i).list)
%                 % more packets are waiting to be sent
%                 mac_status(i) = 1;
%                 newevent = mac_queue(i).list(1);
%                 mac_queue(i).list(1) = [];
%                 newevent.instant = t + cca_time;   % question: should cca_time or other be used here?
%                 newevent.type = 'wait_for_channel';
%                 newevent.node = i;
%                 NewEvents = [NewEvents; newevent]; clear newevent;
%             else
%                 mac_status(i) = 0;
%             end
        end
    case 'send_phy_finish'
        t = event.instant;
        i = event.node;
        j = event.pkt.rv;
        if bdebug, disp(['send_phy_finish @ node ' num2str(i)]); end
        if node(i, 4) ~= 1
            error(['send_phy_finish: node ' num2str(i) ' should be in transmission mode']);
        end
        node(i, 4) = 0; % after all receivings, go back to idle
        node(i, 3) = 0;
        if j==0 % | strcmp(event.pkt.type, 'ack')
            % finished broadcast % or finished RTS-CTS-DATA-ACK for unicast
            if ~isempty(mac_queue(i).list)
                % more packets are waiting to be sent
                mac_status(i) = 1;
                newevent = mac_queue(i).list(1);
                mac_queue(i).list(1) = [];
                newevent.instant = t + cca_time;   % question: should cca_time or other be used here?
                newevent.type = 'wait_for_channel';
                newevent.node = i;
                NewEvents = [NewEvents; newevent]; clear newevent;
            else
                mac_status(i) = 0;
            end
        end
    case 'recv_phy'
        t = event.instant;
        i = event.pkt.tx;
        j = event.node;
        if bdebug, disp(['recv_phy @ node ' num2str(j)]); end
        if node(j, 4) ~= 2
            error(['recv_phy: node ' num2str(j) ' is not in receive mode']);
        end
        node(j, 4) = 0; % receiver switches back to idle mode
        if t > nav(j).start & t < nav(j).end
            % this has already been checked when sending
            % but nav may be changed during transmission, so double check
            if ddebug, disp(['recv_phy: packet virtual collision at node ' num2str(j)]); end
            % just drop the packet
        else
            [pr, snr] = recv_phy(i, j, rmodel);
            % disp(['recv_phy: node ' num2str(i) ' to node ' num2str(j) ' with snr= ' num2str(snr) ' and distance=' num2str(topo_dist(i, j))]);
            t1 = rv_threshold_delta;
            if snr >= (rv_threshold+t1)
                probability_receive = 1;
            elseif snr < (rv_threshold-t1)
                probability_receive = 0;
            elseif rand <= (snr-(rv_threshold-t1))/(t1+t1)
                probability_receive = 1;
            else
                probability_receive = 0;
            end
            if probability_receive
                if event.pkt.rv == 0 | event.pkt.rv == j   % broadcast or unicast to this receiver
                    % TTL is taken care of at network layer
                    % event.pkt.ttl = event.pkt.ttl - 1;
                    % if event.pkt.ttl < 0
                    %     if adebug, disp(['recv_phy: TTL from node ' num2str(i) ' to node ' num2str(j) ' is negative, drop the packet']); end
                    %     return;
                    % end
                    % there is already a MAC layer packet waiting for transmission, but this incoming packet should be
                    % received first, no futher receiving is possible (see send_phy)
                    % if mac_status(j)
                    %     if adebug, disp(['recv_phy: node ' num2str(j) ' is waiting to transmit, so cannot receive']); end
                    newevent = event;
                    newevent.instant = t;
                    newevent.type = 'recv_mac';
                    newevent.node = j;
                    NewEvents = [NewEvents; newevent]; clear newevent;
                elseif event.pkt.nav > 0    % this packet is not for me, but use its nav
                    if nav(j).start < t
                        nav(j).start = t;
                    end
                    if nav(j).end < (t+event.pkt.nav)
                        % question: debug
                        nav(j).end = t + event.pkt.nav;
                    end
                end
            else
                if bdebug, disp(['recv_phy: packet from node ' num2str(i) ' cannot be successfully received at node' num2str(j)]); end
            end
        end
    case 'send_mac'
        t = event.instant;
        i = event.node;
        j = event.pkt.rv;
        if bdebug, disp(['send_mac: node ' num2str(i) ' to send to node ' num2str(j) ' isempty(mac_queue)=' num2str(isempty(mac_queue(i).list)) ' mac_status=' num2str(mac_status(i))]); end
        event.pkt.id = new_id(i);
        event.pkt.type = 'data';    % used in function call of 'tx_time'
        % the tx_time should be the same as in 'send_phy'
        event.pkt.nav = SIFS + cts_tx_time + SIFS + tx_time(event.pkt) + SIFS + ack_tx_time;
        % if ddebug, disp(['send_mac node ' num2str(i) ' will reserve NAV=' num2str(event.pkt.nav)]); end
        if j ~= 0
            % for unicast, RTS should be sent first
            event.pkt.type = 'rts';
        end
        % keep the data body size and rate for transmitting data later
        if ~isempty(mac_queue(i).list) & ~mac_status(i)
            error(['send_mac: node ' num2str(i) ' channel is free, but there is still packets waiting at MAC...this should not happen']);
        end
        if ~isempty(mac_queue(i).list) | mac_status(i)
            % old packets are waiting to be sent, just wait behind them
            % or one packet is being transmitted at MAC layer, just wait in the MAC queue
            mac_queue(i).list = [mac_queue(i).list event];
        else
            mac_status(i) = 1;
            % newevent.instant = t + turnaround_time; % swith to transmit
            newevent = event;
            newevent.instant = t + cca_time;    % check channel status
            newevent.type = 'wait_for_channel';
            newevent.node = i;
            NewEvents = [NewEvents; newevent]; clear newevent;
        end
    case 'wait_for_channel'
        t = event.instant;
        i = event.node;
        j = event.pkt.rv;
        if bdebug, disp(['wait_for_channel @ node ' num2str(i)]); end
%         if mac_status(i) == 0
%             % Reset by timeout_rreq after many RREQ retries
%             if ddebug, disp(['wait_for_channel: node ' num2str(i) 'mac_status reset because so many RREQ retries at network layer']); end
%             return;
%         end
        if node(i, 4) == 0 & carrier_sense(i) == 0
            % question: I want to transmit, but have to capture from many neighbors
            % the node is idle and the channel is free, can backoff now
            if backoff_counter(i) > 0   % resume the backoff
                newevent = event;
                newevent.instant = t + slot_time;
                newevent.type = 'backoff';
                newevent.node = i;
                NewEvents = [NewEvents; newevent]; clear newevent;
            else                        % start from DIFS first
                newevent = event;
                newevent.instant = t + DIFS;
                newevent.type = 'backoff_start';
                newevent.node = i;
                NewEvents = [NewEvents; newevent]; clear newevent;
            end
        else
            % the node is not idle; must be receiving...wait until this receiving is finished
            % or the channel is not free; wait until the channel is free
            newevent = event;
            newevent.instant = t + cca_time;
            newevent.type = 'wait_for_channel';
            newevent.node = i;
            NewEvents = [NewEvents; newevent]; clear newevent;
        end
    case 'backoff_start'  % after DIFS, start backoff
        t = event.instant;
        i = event.node;
        j = event.pkt.rv;
        if bdebug, disp(['backoff_start @ node ' num2str(i)]); end
        if node(i, 4) == 0 & carrier_sense(i) == 0
            % the node is still idle and the channel is free, start backoff
            % question: what if the channel was busy during this DIFS period?
            backoff_attempt(i) = 0;
            temp = min(backoff_attempt(i)+CW_min,CW_max);
            backoff_counter(i) = floor((2^temp-1)*rand);
            newevent = event;
            newevent.instant = t + slot_time;
            newevent.type = 'backoff';
            newevent.node = i;
            NewEvents = [NewEvents; newevent]; clear newevent;
        else
            % channel becomes busy during DIFS, wait until the channel is free
            newevent = event;
            newevent.instant = t + cca_time;
            newevent.type = 'wait_for_channel';
            newevent.node = i;
            NewEvents = [NewEvents; newevent]; clear newevent;
        end
    case 'backoff'
        t = event.instant;
        i = event.node;
        j = event.pkt.rv;
        if bdebug, disp(['backoff @ node ' num2str(i)]); end
        if node(i, 4) == 0 & carrier_sense(i) == 0
            % the node is still idle and the channel is free, continue backoff
            if backoff_counter(i) > 1
                backoff_counter(i) = backoff_counter(i) - 1;
                newevent = event;
                newevent.instant = t + slot_time;
                newevent.type = 'backoff';
                newevent.node = i;
                NewEvents = [NewEvents; newevent]; clear newevent;
            else    % ready to send the packet
                backoff_counter(i) = 0; % reset counter for next use
                newevent = event;
                newevent.instant = t;
                newevent.type = 'send_phy';
                newevent.node = i;
                NewEvents = [NewEvents; newevent];
                % txtime = tx_time(newevent.pkt);
                clear newevent;
                % mac_queue will be taken care of after really send this packet in 'send_phy_finish'
%                 if j == 0   % broadcast: the real data is sent here
%                     % we can send the next packet from mac_queue now
%                     if ~isempty(mac_queue(i).list)
%                         % more packets are waiting to be sent
%                         newevent = mac_queue(i).list(1);
%                         mac_queue(i).list(1) = [];
%                         newevent.instant = t + txtime + cca_time;   % question: should cca_time or other be used here?
%                         newevent.type = 'wait_for_channel';
%                         newevent.node = i;
%                         NewEvents = [NewEvents; newevent]; clear newevent;
%                     else
%                         % will reset in 'send_phy_finish'
%                         % mac_status(i) = 0;
%                     end
%                 else
%                     % unicast: the RTS is sent here, will wait for CTS or timeout_rts
%                     % do nothing here
%                 end
            end
        else   % channel becomes busy during backoff count-down
            if backoff_counter(i) > 1
                backoff_counter(i) = backoff_counter(i) - 1;
            else
                % start a new backoff counter when count-down is zero
                backoff_attempt(i) = backoff_attempt(i) + 1;
                temp = min(backoff_attempt(i)+CW_min,CW_max);
                backoff_counter(i) = floor((2^temp-1)*rand);
            end
            newevent = event;
            newevent.instant = t + cca_time;
            newevent.type = 'wait_for_channel';
            newevent.node = i;
            NewEvents = [NewEvents; newevent]; clear newevent;
        end
    case 'timeout_rts'
        t = event.instant;
        i = event.node;
        j = event.pkt.rv;
        if adebug, disp(['timeout_rts @ node ' num2str(i)]); end
        if pending_id(i) == event.pkt.id % not acknowledged yet, retransmit
            if cdebug, disp(['timeout_rts: node ' num2str(i) ' pending_id=' num2str(pending_id(i)) ' event_id=' num2str(event.pkt.id)]); end
            retransmit(i) = retransmit(i) + 1;
            if retransmit(i) > max_retries
                % so many retries, drop the packet
                if cdebug, disp(['timeout_rts: node ' num2str(i) ' has retried so many times to transmit RTS']); end
                retransmit(i) = 0;
                pending_id(i) = 0;
                % question: what if there are waiting packets in mac_queue?
                % answer: should send them anyway as if the current packet is done.
                % similar to the the operation when ACK is received
                if ~isempty(mac_queue(i).list)
                    % more packets are waiting to be sent
                    % newevent.instant = t + turnaround_time; % switch from receive to transmit
                    mac_status(i) = 1;
                    newevent = mac_queue(i).list(1);
                    mac_queue(i).list(1) = [];
                    newevent.instant = t + cca_time;    % question: cca_time or other
                    newevent.type = 'wait_for_channel';
                    newevent.node = i;
                    % packet setup is already done in 'send_mac' before put into the mac_queue
                    NewEvents = [NewEvents; newevent]; clear newevent;
                else
                    % cannot send RTS successfully, reset MAC layer
                    mac_status(i) = 0;
                end
                return;
            end
            if adebug, disp(['timeout_rts: node ' num2str(i) ' to retransmit RTS']); end
            % retransmit the RTS
            newevent = event;
            newevent.instant = t + cca_time;    % check channel status
            newevent.type = 'wait_for_channel';
            newevent.node = i;
            NewEvents = [NewEvents; newevent]; clear newevent;
        else
            % if pending_id(i) ~= 0 & ddebug, disp(['timeout_rts at node ' num2str(i) ' pending id=' num2str(pending_id(i)) ' does not match the waiting RTS id=' num2str(event.pkt.id)]); end
        end
    case 'timeout_data'
        t = event.instant;
        i = event.node;
        j = event.pkt.rv;
        if adebug, disp(['timeout_data @ node ' num2str(i)]); end
%         if pending_id(i) == event.pkt.id % not acknowledged yet
%             if adebug, disp(['timeout_data: node ' num2str(i) ' failed to transmit DATA, go back to transmit RTS']); end
%             % remove the pending id for DATA
%             pending_id(i) = 0;
%             retransmit(i) = 0;
%             % go back to send RTS
%             newevent = event;
%             newevent.instant = t + cca_time;    % check channel status
%             newevent.type = 'wait_for_channel';
%             newevent.node = i;
%             newevent.pkt.type = 'data';
%             newevent.pkt.nav = SIFS + cts_tx_time + SIFS + tx_time(newevent.pkt) + SIFS + ack_tx_time;
%             newevent.pkt.type = 'rts';
%             % create a new id for the new RTS
%             newevent.pkt.id = new_id(i);
%             NewEvents = [NewEvents; newevent]; clear newevent;
%         end
        if pending_id(i) == event.pkt.id % not acknowledged yet
            if cdebug, disp(['timeout_data: node ' num2str(i) ' pending_id=' num2str(pending_id(i)) ' event_id=' num2str(event.pkt.id)]); end
            retransmit(i) = retransmit(i) + 1;
            if retransmit(i) > max_retries
                % so many retries, drop the data packet
                if cdebug, disp(['timeout_data: node ' num2str(i) ' has retried so many times to transmit DATA']); end
                retransmit(i) = 0;
                pending_id(i) = 0;
                if ~isempty(mac_queue(i).list)
                    % more packets are waiting to be sent
                    mac_status(i) = 1;
                    newevent = mac_queue(i).list(1);
                    mac_queue(i).list(1) = [];
                    newevent.instant = t + cca_time;    % question: cca_time or other
                    newevent.type = 'wait_for_channel';
                    newevent.node = i;
                    NewEvents = [NewEvents; newevent]; clear newevent;
                else
                    % Cannot send DATA successfully, reset MAC layer
                    mac_status(i) = 0;
                end
                return;
            end
            if adebug, disp(['timeout_data: node ' num2str(i) ' to retransmit DATA']); end
            % retransmit the DATA
            newevent = event;
            newevent.instant = t + cca_time;    % check channel status
            newevent.type = 'wait_for_channel';
            newevent.node = i;
            % newevent.pkt.type = 'data';
            newevent.pkt.nav = SIFS + ack_tx_time; % necessary for retransmission because the initial DATA has NAV=0
            NewEvents = [NewEvents; newevent]; clear newevent;
        end
    case 'recv_mac'
        t = event.instant;
        i = event.pkt.tx;
        j = event.node;
        if adebug, disp(['recv_mac @ node ' num2str(j)]); end
        if event.pkt.rv == 0 & strcmp(event.pkt.type, 'data') == 0
            % broadcast but not data packet
            error(['recv_mac: node ' num2str(j) ' receives a broadcast packet with a wrong type: ' event.pkt.type]);
        end
        if j == i
            % I myself sent this packet, no action
            return;
        end
        switch event.pkt.type
            case 'rts'
                % send back a CTS
                newevent = event;
                newevent.instant = t + SIFS;
                newevent.type = 'send_phy';
                newevent.node = j;
                % keep the data size, rate, and id as RTS packet
                newevent.pkt.type = 'cts';
                newevent.pkt.tx=j;
                newevent.pkt.rv=i;
                newevent.pkt.nav=event.pkt.nav - SIFS - cts_tx_time;
                NewEvents = [NewEvents; newevent]; clear newevent;
            case 'cts'
                % remove pending id for RTS
                if pending_id(j) ~= event.pkt.id
                    if ddebug, disp(['the received CTS id ' num2str(event.pkt.id) ' does not match the pending RTS id ' num2str(pending_id(j))]); end
                    % probably this CTS is in response to an earlier RTS,
                    % but I have retransmitted a new RTS which is replied
                    % already or I have retransmitted so many times and given up
                    % so we just ignore this CTS.
                    return;
                end
                pending_id(j) = 0;
                retransmit(j) = 0;
                % send DATA
                newevent = event;
                newevent.instant = t + SIFS;