% ######
%A1 get sequence for current block (for now just one)
% ######
b = 1; % block index (set constant to 1 until future changes)
currSEQ = length(DESIGN.trial_seq);
trialseq = DESIGN.trial_seq{currSEQ};      % grab current sequence
outVars = zeros(size(trialseq));  % initialize an output variable matrix


% ######
%A2 get ready to start - DISPLAY READY SCREEN
% ######
if FLAG_MRI
Screen('TextSize', w, 28);
Screen('DrawText',w,sprintf('Get ready to start... '),xcenter-140,ycenter);
Screen('Flip',w);
else
Screen('TextSize', w, 28);
Screen('DrawText',w,sprintf('Press space to start... '),xcenter-140,ycenter);
Screen('Flip',w);
end

% ######
%A3 watch for any keypress if behavior, for trigger if fMRI!
% ######
if FLAG_MRI 
    trigger = KbName('t');
    timer_started = 1;
    while timer_started
         [timerPressed,time] = KbCheck(experimenter_device); 
         STARTscanner = time;
         if timerPressed
            timer_started = 0;
         end
    end     
    secs=KbTriggerWait(KbName('5%'),inputDevice);
    % note that referencing '5%' is not good practice
    % you ought to assign '5%' to a variable in the av_setupSR.m
    % and reference that variable here instead
    DisableKeysForKbCheck(KbName('5%')); % So trigger is no longer detected
    triggerOFFSET = secs - STARTscanner;
else %running behaviorally (no scanner)
        noresp=1;
        STARTscanner = GetSecs;
      while noresp         
           [keyIsDown,secs,keyCode] = KbCheck(experimenter_device);
           if keyIsDown && noresp 
           noresp=0; 
           triggerOFFSET = secs - STARTscanner;
           if keyCode(escapeKEY), Screen('CloseAll'); error('User escaped experiment!'); end %escapeCheck
           end  
      end
      WaitSecs(0.001);
end

% ######
%A4 Get READY!
% ######
Screen('FillRect', w, 0);
Screen('Flip',w);

WaitSecs(0.9);
PsychPortAudio('FillBuffer', pahandle, [WARNING;WARNING]);
PsychPortAudio('Start', pahandle, 1, 0, 0);
WaitSecs(3);

% ######
%A5 THE KEYBOARD COMMAND
% ######
% keyboard

% time stamp for block start
blockStart = GetSecs;
startTime = GetSecs;
    
nEvents = length(trialseq);     
tcount = 1;  %just an event timer

% ######
%A6 EVENT LOOP
% ######
for e = 1:nEvents
 
    
    %##############################
    % SET SOME VARIABLES
    %##############################
    
    % get event variables
    iEVENT = (b-1)*nEvents + e;
    TRIAL_DUR = trialseq(e,3);       
    
    % sunch timing synch to 'expected' start time
    while (GetSecs - blockStart) < trialseq(e,4), end
    
    %penalize offset if timing is late
    if trialseq(e,1) == null || trialseq(e,1) == rest
        STIM_PENALTY = (GetSecs - blockStart) - trialseq(e,4);
    end
    
    % start event timer
    eventStart = GetSecs; 
    outVars(iEVENT,5) = eventStart-blockStart; %actual event onset
    
    % start counter for trial number (b/c a trial = 2 events)

    if trialseq(e,1) == null
        TRIAL_NUM = tcount;
    else
        TRIAL_NUM = tcount;
        tcount = tcount+1;
    end
    
    
    %##############################
    % START EVENT PRESENTATION
    %##############################
    %keyboard
    TASK_FLAG = TASK_FLAGs(e);
    if trialseq(e,TASK_FLAG) == null 
        
        % ########## NULL EVENT ################
               
        % CORRECT TIMING
        if (TRIAL_DUR - STIM_PENALTY) < 0
            DUR_CORRECTED = 0;
        else
            DUR_CORRECTED = TRIAL_DUR - STIM_PENALTY;
        end
        
        
        % SHOW NOTHING BUT LISTEN FOR RESPONSES FROM PREVIOUS TRIAL
        noresp = 1; resp.resp = 0; resp.time = 0;
        while ((GetSecs - eventStart) < DUR_CORRECTED) && noresp       
            
            [keyIsDown,secs,keyCode] = KbCheck(inputDevice);
            if keyIsDown && noresp                           
                try
                    pressIndx = find(keyCode); 
                    resp.resp = pressIndx(1); 
                    disp(sprintf('%s',KbName(pressIndx)))
                catch
                    resp.resp = 999; %error recording
                end

                resp.time = GetSecs-stimStart; %time since stimulus onset
                noresp=0;
            
                if keyCode(escapeKEY), Screen('CloseAll'); error('User escaped experiment!'); end
            end 
        end        
        
    elseif trialseq(e,TASK_FLAG) == rest  
        
        % ########## REST EVENT ################

        WaitSecs(.5);
        PsychPortAudio('FillBuffer', pahandle, [WARNING;WARNING]);
        PsychPortAudio('Start', pahandle, 1, 0, 0);
       
        
        % CORRECT TIMING
        if (TRIAL_DUR - STIM_PENALTY) < 0
            DUR_CORRECTED = 0;
        else
            DUR_CORRECTED = TRIAL_DUR - STIM_PENALTY;
        end
        
        % SHOW WARNING JUST BEFORE NEXT HALF
        fprintf('\n... please rest ...\n')

        while ((GetSecs - eventStart) < DUR_CORRECTED-1.5)     
            
            [keyIsDown,secs,keyCode] = KbCheck(inputDevice);
            if keyIsDown                                      
                if keyCode(escapeKEY), Screen('CloseAll'); error('User escaped experiment!'); end
            end 
        end   
               
        % warning + 1 second interval (other .5 sec is at start)
        % disp(sprintf('Ready...\n'))
        PsychPortAudio('FillBuffer', pahandle, [WARNING;WARNING]);
        PsychPortAudio('Start', pahandle, 1, 0, 0);
        WaitSecs(1);
        
    else 
        

        % ############# TASK EVENT ###########
        
        stimStart = GetSecs; 
        
        % FIGURE OUT WHICH STIMULUS AND MODALITY(IES) TO SHOW
        AUDSTIM = AUDIO(trialseq(e,audio),:);
        LEDSTIM = LED{trialseq(e,led),:};

        if DUAL_FLAG
            % both get a stimulus
            CURR_STIMULUS_A = [AUDSTIM; AUDSTIM];
            CURR_STIMULUS_V = LEDSTIM;
        else
            if TASK_FLAG==audio
                CURR_STIMULUS_A = [AUDSTIM; AUDSTIM];
                CURR_STIMULUS_V = [0];
            else
                CURR_STIMULUS_A = [EMPTY_STIM; EMPTY_STIM];
                CURR_STIMULUS_V = LEDSTIM;
            end
        end


        % SET CORRECT RESPONSE FOR NULL EVENT
        if TASK_FLAG==audio
            if trialseq(e,audio)==odd, CORRESP = 1; else CORRESP = 0; end
            if trialseq(e,led)==odd, FOILRESP = 1; else FOILRESP = 0; end
        else %led task
            if trialseq(e,led)==odd, CORRESP = 1; else CORRESP = 0; end
            if trialseq(e,audio)==odd, FOILRESP = 1; else FOILRESP = 0; end
        end

        %##############################
        % SHOW EVENT (SIMULTANEOUSLY!)
        %##############################

        PsychPortAudio('FillBuffer', pahandle, CURR_STIMULUS_A);

        PsychPortAudio('Start', pahandle, 1, 0, 0);
        Screen(w,'PutImage',CURR_STIMULUS_V);   
        Screen(w,'Flip');

        WaitSecs(TRIAL_DUR);        

        Screen(w,'FillRect',0);   
        Screen(w,'Flip');
        %##############################        
        
        % correct timing if ended short (unlikely!)
        % penalty for ending late is added at START of trial
        while((GetSecs - blockStart) < (trialseq(e,3) + trialseq(e,4))), end
    end
    

    %##############################
    % RECORD VARIABLES FOR CURRENT TRIAL
    %##############################
    
    outVars(iEVENT,1:4) = trialseq(e,1:4);

    if trialseq(e,1) == null 
        
        corr = 0; falsealarm = 0; miss = 0;
        if CORRESP == 1
            % either got it or missed it
            if resp.resp > 0, corr = 1; else miss = 1; end
        else
      	    % either skipped correctly or false alarm
            if resp.resp > 0, falsealarm = 1; else corr = 1; end
        end
        outVars(iEVENT-1,6) = resp.resp; 
        outVars(iEVENT-1,7) = resp.time;
        outVars(iEVENT-1,8) = corr;
        outVars(iEVENT-1,9) = miss;
        outVars(iEVENT-1,10) = falsealarm;
        if DUAL_FLAG, outVars(iEVENT-1,11) = FOILRESP; else end
    end
    outVars(iEVENT,12) = e; %event
    outVars(iEVENT,13) = TRIAL_NUM; %trialnum
    outVars(iEVENT,14) = b; %block
    outVars(iEVENT,15) = TASK_FLAG;
    
    % WRITE TO FILE
    try
        fprintf(fid,'\n');
        fprintf(fid,'%d\t%d\t%0.2f\t%0.2f\t%0.2f\t%d\t%0.3f\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d',outVars(iEVENT,:));
    catch   % ERROR
        fprintf(fid,'\n');        
        fprintf(fid,'%d\t%d\t%0.2f\t%0.2f\t%0.2f\t%d\t%0.3f\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d',ones(1,size(outVars(iEVENT,:),2)).*77);
    end
    
end % TRIAL_SEQ


% BLOCK LEVEL RESULTS
currBLOCK = find(outVars(:,14)==b);
blockDATA = outVars(currBLOCK,:);

trialIndex_a = find(ismember(blockDATA(:,15),audio) & ismember(blockDATA(:,1),[1 2]));
trialIndex_v = find(ismember(blockDATA(:,15),led) & ismember(blockDATA(:,1),[1 2]));

oddIndex_a = find(ismember(blockDATA(:,15),audio) & ismember(blockDATA(:,audio),2));
oddIndex_v = find(ismember(blockDATA(:,15),led) & ismember(blockDATA(:,led),2));

oddIndexCORR_a = find(ismember(blockDATA(:,15),audio) & ismember(blockDATA(:,audio),2) & ismember(blockDATA(:,8),1));
oddIndexCORR_v = find(ismember(blockDATA(:,15),led) & ismember(blockDATA(:,led),2) & ismember(blockDATA(:,8),1));

blockAccuracy_a = mean(blockDATA(oddIndex_a,8));
blockMissed_a = mean(blockDATA(trialIndex_a,9));
blockFalseAlarms_a = mean(blockDATA(trialIndex_a,10));
blockRT_a = mean(blockDATA(oddIndexCORR_a,7));

blockAccuracy_v = mean(blockDATA(oddIndex_v,8));
blockMissed_v = mean(blockDATA(trialIndex_v,9));
blockFalseAlarms_v = mean(blockDATA(trialIndex_v,10));
blockRT_v = mean(blockDATA(oddIndexCORR_v,7));

% block duration
finishTime = GetSecs - startTime;
SESSION.specs.wait(b) = 2;
SESSION.specs.blockDuration(b) = finishTime;
        
% trailing time blank screen if scanning
if FLAG_MRI
    spareTime = 390 - finishTime;       % we expect 6' 30'' duration
    if spareTime < 0, spareTime=0; end
    Screen('FillRect', w, 0);
    Screen('Flip',w);
    WaitSecs(spareTime);
    SESSION.specs.spareTime(b)=spareTime;   
    SESSION.specs.triggerOFFSET(b)=triggerOFFSET;
end 

% show feedback and wait for key press to finish experiment
Screen('TextSize', w, 16);
Screen('DrawText',w,sprintf('Audio TARGETS DETECTED %0.2f %%',blockAccuracy_a.*100),xcenter-140,ycenter-100);
Screen('DrawText',w,sprintf('Audio TARGETS MISSED %0.2f %%',blockMissed_a.*100),xcenter-140,ycenter-75);
Screen('DrawText',w,sprintf('Audio FALSE ALARMS %0.2f %%',blockFalseAlarms_a.*100),xcenter-140,ycenter-50);
Screen('DrawText',w,sprintf('Audio RT %2.2f ms',blockRT_a.*1000),xcenter-140,ycenter-25);

Screen('DrawText',w,sprintf('Visual TARGETS DETECTED %0.2f %%',blockAccuracy_v.*100),xcenter-140,ycenter+25);
Screen('DrawText',w,sprintf('Visual TARGETS MISSED %0.2f %%',blockMissed_v.*100),xcenter-140,ycenter+50);
Screen('DrawText',w,sprintf('Visual FALSE ALARMS %0.2f %%',blockFalseAlarms_v.*100),xcenter-140,ycenter+75);
Screen('DrawText',w,sprintf('Visual RT %2.2f ms',blockRT_v.*1000),xcenter-140,ycenter+100);
Screen('Flip',w);

% display for at least 2 seconds
WaitSecs(2);
noresp=1;
while noresp         
    [keyIsDown,secs,keyCode] = KbCheck(inputDevice);
    if keyIsDown && noresp 
        noresp=0; 
        if keyCode(escapeKEY), Screen('CloseAll'); error('User escaped experiment!'); end %escapeCheck
    end  
end
WaitSecs(0.001);
