function cmds = getBlockCommands(blocks)

% GETBLOCKCOMMANDS get a set of commands from a set of sLTPDA blocks.
%
% M Hewitson 27-03-07
%


disp('   + compiling block list');

cmds = [];

for j=1:length(blocks)
  b         = blocks(j);
  blocktype = get(b, 'BlockType');
  maskType = get(b, 'MaskType');
  name      = get(b, 'Name');
  if ~strcmp(name, 'variable')
    parent    = get(b, 'Parent');
    name = [parent '_' name];
    name = sltpda_reduceVarName(name);

    if ~strcmp(blocktype, 'Outport') && ~strcmp(blocktype, 'Inport') && ~strcmp(maskType, 'loop')
      fcn       = getFcnName(b);
      if ~isempty(fcn)

        % Get my inputs and outputs
        [inames, onames] = getIOnames(get(b, 'PortHandles'), name);

        % Get my parameters
        [params, pl] = getParameters(b);

        % Form command
        %       cmd = buildCmd(inames, onames, params, fcn);
        cmd = sltpda_buildCmd(inames, onames, params, fcn);

        % store info
        info.fcn      = fcn;
        info.params   = params;
        info.plist    = pl;
        info.ins      = inames;
        info.outs     = onames;
        info.outsUsed = [];
        info.cmd      = cmd;
        info.name     = get(b, 'Name');
        info.handle   = get(b, 'Handle');
        info.ranges   = [];

        cmds = [cmds info];
      end
    end
  end
end


%--------------------------------------------------------------------------
% Get parameters from block mask
% 
% MaskPromptString, MaskVariables, MaskValueString
% 
function [params, pl] = getParameters(block)

params = [];
pl = plist();
try
  maskType = get(block, 'MaskType');  
end

if ~isempty(maskType)
  switch maskType

    case 'ltpda_tfe'
      [params, pl] = get_ltpda_tfe_params(block);
    case 'ltpda_pwelch'
      [params, pl] = get_ltpda_pwelch_params(block);
    case 'plot'
      [params, pl] = get_plot_params(block);
    case 'ao'
      [params, pl]  = get_ao_params(block);
    case 'filter'
      [params, pl] = get_filter_params(block);
    case 'get'
      [params, pl] = get_get_params(block);
    case 'rdivide'
      [params, pl] = get_mrdivide_params(block);
    case 'minus'
      [params, pl] = get_minus_params(block);
    case 'plus'
      [params, pl] = get_plus_params(block);
    case 'times'
      [params, pl] = get_mtimes_params(block);
    case 'sqrt'
      [params, pl] = get_sqrt_params(block);
    case 'abs'
      [params, pl] = get_abs_params(block);
    case 'split'
      [params, pl] = get_split_params(block);
    case 'demux'
      [params, pl] = get_demux_params(block);
    case 'ltpda_timedomainfit'
      [params, pl] = get_ltpda_timedomainfit_params(block);
    case 'ltpda_lincom'
      [params, pl] = get_ltpda_lincom_params(block);
    case 'ltpda_polydetrend'
      [params, pl] = get_ltpda_polydetrend_params(block);
    case 'ltpda_lpsd'
      [params, pl] = get_ltpda_lpsd_params(block);
    case 'save'
      [params, pl] = get_save_params(block);
    case 'resample'
      [params, pl] = get_resample_params(block);
    case 'pzmresp'
      [params, pl] = get_pzmresp_params(block);
    case 'convert'
      [params, pl] = get_convert_params(block);
    case 'param'
      [params, pl] = get_param_params(block);
    case 'iparam'
      [params, pl] = get_iparam_params(block);
    case 'specwin'
      [params, pl] = get_specwin_params(block);
    case 'plist'
      [params, pl] = get_plist_params(block);
    case 'display'
      pl = [];
      params = '';
    case 'pole'
      [params, pl] = get_pole_params(block);
    case 'zero'
      [params, pl] = get_zero_params(block);
    case 'pzmodel'
      [params, pl] = get_pzmodel_params(block);
    case 'resp'
      [params, pl] = get_resp_params(block);
    case 'miir'
      [params, pl] = get_miir_params(block);
    case 'iirResp'
      [params, pl] = get_iirResp_params(block);
    otherwise
      warning(['### unknown mask type ' maskType]);
  end
else
  pl = plist();
  params = [];
end

%--------------------------------------------------------------------------
% Get parameters for abs block.
% 
function [params, pl]  = get_abs_params(block)

% build output
pl = plist();
params = '';

%--------------------------------------------------------------------------
% Get parameters for iirResp block.
% 
function [params, pl]  = get_iirResp_params(block)

f1    = get(block, 'f1');
f2    = get(block, 'f2');
nf    = get(block, 'nf');

if isempty(f1)
  f1 = '[]';
end
if isempty(f2)
  f2 = '[]';
end
if isempty(nf)
  nf = '[]';
end
% build output
pl = plist( [param('f1', eval(f1)) param('f2', eval(f2)) param('nf', eval(nf))] );
params = string(pl);

%--------------------------------------------------------------------------
% Get parameters for miir block.
% 
function [params, pl]  = get_miir_params(block)

fs    = get(block, 'fs');

if isempty(fs)
  fs = '[]';
end
% build output
pl = plist( param('fs', eval(fs)) );
params = string(pl);

%--------------------------------------------------------------------------
% Get parameters for resp block.
% 
function [params, pl]  = get_resp_params(block)

f1    = get(block, 'f1');
f2    = get(block, 'f2');
nf    = get(block, 'nf');
scale = get(block, 'scale');

if isempty(f1)
  f1 = '[]';
end
if isempty(f2)
  f2 = '[]';
end
if isempty(nf)
  nf = '[]';
end
% build output
pl = plist( [param('f1', eval(f1)) param('f2', eval(f2)) param('nf', eval(nf)) param('scale', scale)] );
params = string(pl);


%--------------------------------------------------------------------------
% Get parameters for pzmodel block.
% 
function [params, pl]  = get_pzmodel_params(block)

% build output
pl = plist();
params = '';

%--------------------------------------------------------------------------
% Get parameters for zero block.
% 
function [params, pl]  = get_zero_params(block)

f = get(block, 'zerof');
q = get(block, 'zeroQ');
if isempty(q)
  q = '0';
end

% build output
pl = plist( [param('f', eval(f)) param('q', eval(q))] );
params = string(pl);


%--------------------------------------------------------------------------
% Get parameters for pole block.
% 
function [params, pl]  = get_pole_params(block)

f = get(block, 'polef');
q = get(block, 'poleQ');
if isempty(q)
  q = '0';
end

% build output
pl = plist( [param('f', eval(f)) param('q', eval(q))] );
params = string(pl);


%--------------------------------------------------------------------------
% Get parameters for plist block.
% 
function [params, pl]  = get_plist_params(block)

% build output
pl = plist();
params = '';

%--------------------------------------------------------------------------
% Get parameters for iparam block.
% 
function [params, pl]  = get_iparam_params(block)

key = get(block, 'key');


% build output
pl = plist(param(key, -1));
params = string(pl);


%--------------------------------------------------------------------------
% Get parameters for specwin block.
% 
function [params, pl]  = get_specwin_params(block)

name = get(block, 'wname');
N    = get(block, 'wlen');
psll = get(block, 'psll');

% check what value is


% build output
pl = plist([param('Name', name) param('N', eval(N)) param('PSLL', eval(psll))]);
params = string(pl);

%--------------------------------------------------------------------------
% Get parameters for param block.
% 
function [params, pl]  = get_param_params(block)

key = get(block, 'key');
val = get(block, 'val');


% build output
pl = plist([param('key', key) param('val', eval(val))]);
params = string(pl);

%--------------------------------------------------------------------------
% Get parameters for convert block.
% 
function [params, pl]  = get_convert_params(block)

pl = plist();
params = '';

%--------------------------------------------------------------------------
% Get parameters for pzmresp block.
% 
function [params, pl]  = get_pzmresp_params(block)

f1 = get(block, 'f1');
f2 = get(block, 'f2');
nf = get(block, 'nf');
pzm = get(block, 'pzm');

pl = plist();
if ~isempty(f1)
  pl = append(pl, param('f1', str2double(f1)));
end
if ~isempty(f2)
  pl = append(pl, param('f2', str2double(f2)));
end
if ~isempty(nf)
  pl = append(pl, param('nf', str2double(nf)));
end
if ~isempty(pzm)
  pl = append(pl, param('pzmodel', eval(pzm)));
else
  error('### pole/zero constructor is empty.');
end
params = string(pl);


%--------------------------------------------------------------------------
% Get parameters for resample block.
% 
function [params, pl]  = get_resample_params(block)

fsout = get(block, 'fsout');
pl = plist();
pl = append(pl, param('fsout', str2double(fsout)));
params = string(pl);

%--------------------------------------------------------------------------
% Get parameters for save block.
% 
function [params, pl]  = get_save_params(block)

fname = get(block, 'fname');
pl = plist();
pl = append(pl, param('filename', fname));
params = string(pl);


%--------------------------------------------------------------------------
% Get parameters for ltpda_lpsd block.
% 
function [params, pl] = get_ltpda_lpsd_params(block)

Kdes = str2double(get(block, 'Kdes'));
Kmin = str2double(get(block, 'Kmin'));
Jdes = str2double(get(block, 'Jdes'));
Win = get(block, 'win');
nolap   = str2double(get(block, 'olap'));
psll    = str2double(get(block, 'psll'));

params = [];
pl = plist(param('Kdes', Kdes));
pl = append(pl, param('Kmin', Kmin));
pl = append(pl, param('Jdes', Jdes));

nfft = 10;
switch Win
  case 'Kaiser'
    if psll <=0 
      error('### ltpda_lpsd block: please specify PSLL for Kaiser window.')
    end
    p = sprintf('specwin(''Kaiser'', %f, %f)', nfft, psll);
  case 'Hanning'
    p = sprintf('specwin(''Hanning'', %f)', nfft);
  otherwise
    error('### ltpda_lpsd block: Unknown window name.');
end

pl = append(pl, param('win', eval(p)));
if nolap > 0
  pl = append(pl, param('Olap', nolap));
end

params = string(pl);


%--------------------------------------------------------------------------
% Get parameters for ltpda_polydetrend block.
% 
function [params, pl] = get_ltpda_polydetrend_params(block)

N = get(block, 'degree');

params = [];
pl = plist(param('N', N));
params = string(pl);



%--------------------------------------------------------------------------
% Get parameters for ltpda_lincom block.
% 
function [params, pl] = get_ltpda_lincom_params(block)


coeffs = get(block, 'coeffs');

params = [];
pl = plist(param('coeffs', coeffs));
params = string(pl);


%--------------------------------------------------------------------------
% Get parameters for ltpda_timedomainfit block.
% 
function [params, pl] = get_ltpda_timedomainfit_params(block)

params = [];
pl = plist();


%--------------------------------------------------------------------------
% Get parameters for demux block.
% 
function [params, pl] = get_demux_params(block)

params = [];
pl = plist();

%--------------------------------------------------------------------------
% Get parameters for sqrt block.
% 
function [params, pl] = get_split_params(block)

method = get(block, 'method');
splits = get(block, 'splits');

pl = plist();
pl = append(pl, param(method, str2num(splits) ));
params = string(pl);


%--------------------------------------------------------------------------
% Get parameters for sqrt block.
% 
function [params, pl] = get_sqrt_params(block)

pl = plist();
params = [];

%--------------------------------------------------------------------------
% Get parameters for mrdivide block.
% 
function [params, pl] = get_mrdivide_params(block)

pl = plist();
params = [];

%--------------------------------------------------------------------------
% Get parameters for mtimes block.
% 
function [params, pl] = get_mtimes_params(block)

pl = plist();
params = [];

%--------------------------------------------------------------------------
% Get parameters for minus block.
% 
function [params, pl] = get_minus_params(block)

pl = plist();
params = [];

%--------------------------------------------------------------------------
% Get parameters for plus block.
% 
function [params, pl] = get_plus_params(block)

pl = plist();
params = [];

%--------------------------------------------------------------------------
% Get parameters for get block.
% 
function [params, pl] = get_get_params(block)

pl = plist();
params = ['''' get(block, 'param') ''''];

%--------------------------------------------------------------------------
% Get parameters for filter block.
% 
function [params, pl] = get_filter_params(block)


% first we try for a standard filter
fname = [];
ftype = [];
try 
  ftype  = get(block, 'ftype');
  fgain  = get(block, 'fgain');
  ffc    = get(block, 'ffc');
  forder = get(block, 'forder');
  % we design for 4*ffc and adjust later when
  % we know the fs of the input data
  fc     = str2num(ffc);
  ffs    = 4*fc(end);
catch 
  try
    fname = get(block, 'fname');
  catch 
  end
end


% start plist
pl = plist();
if isempty(fname)
  
  % if not a standard filter, then a pole/zero filter
  if isempty(ftype)
    
    miirstr = get(block, 'miirstr');
    eval(['pzm = ' miirstr ';']);
    pl      = plist(param('filter', miir(plist(param('pzmodel', pzm)))));
    params  = string(pl);
    
  % else a standard filter  
  else
    
    % build standard filter
    if strcmp(ftype, 'bandpass') || strcmp(ftype, 'bandreject')
      if length(str2num(ffc)) ~= 2
        error('### supply upper and lower frequency for bandpass and bandreject filters.');
      end
    end

    fpl = plist();
    fpl = append(fpl, param('type', ftype));
    fpl = append(fpl, param('gain', str2double(fgain)));
    %   fpl = append(fpl, param('fs', (ffs)));
    fpl = append(fpl, param('fc', [str2num(ffc)]));
    fpl = append(fpl, param('order', [str2num(forder)]));

    pl = plist(param('filter', miir(fpl)));
    params = string(pl);
  end
else  
  pl = plist(param('filter', miir(fname)));
  params = string(pl);
end

%--------------------------------------------------------------------------
% Get parameters for ao block.
% 
function [params, pl]  = get_ao_params(block)

fname    = [];
vals     = [];
fcn      = [];
tsfcn    = [];
waveform = [];
try fname    = get(block, 'fname'); end;
try vals     = get(block, 'vals'); end;
try fcn      = get(block, 'fcn'); end;
try tsfcn    = get(block, 'tsfcn'); end;
try waveform = get(block, 'waveform'); end;

% execute 
if ~isempty(fname)
  pl = plist();
  pl = append(pl, param('filename', fname));
  params = string(pl);
elseif ~isempty(vals)
  pl = plist(param('vals', str2num(vals)));
  params = string(pl);
elseif ~isempty(fcn)
  pl = plist(param('fcn', fcn));
  params = string(pl);
elseif ~isempty(tsfcn)
  nsecs = sltpda_getvar(block, 'nsecs');
  fs    = sltpda_getvar(block, 'fs');
  pl = plist();
  pl = append(pl, param('nsecs', nsecs));
  pl = append(pl, param('fs', fs));
  pl = append(pl, param('tsfcn', tsfcn));
  params = string(pl);
elseif ~isempty(waveform)
  
  switch waveform
    %------------ Sine Wave
    case 'sine wave'
      freq = get(block, 'freq');
      phi  = get(block, 'phi');
      tsfcn = sprintf('sin(2*pi*%f*t + %f*pi/180)', eval(freq), eval(phi));
    %------------ Noise
    case 'noise'
      ntype = get(block, 'ntype');
      switch ntype
        case 'Normal'
          tsfcn = 'randn(size(t))';
        case 'Uniform'
          tsfcn = 'rand(size(t))';
      end
    %------------ Chirp
    case 'chirp'
      f0  = get(block, 'chirp_f0');
      fe  = get(block, 'chirp_fe');
      te  = get(block, 'chirp_te');
      tsfcn = sprintf('chirp(t,%f,%f,%f)', eval(f0), eval(fe), eval(te))
    %------------ Gaussian pulse
    case 'Gaussian pulse'
      fc  = get(block, 'gp_f0');
      bw  = get(block, 'gp_bw');
      tsfcn = sprintf('gauspuls(t,%f,%f)', eval(fc), eval(bw));
    case 'Square wave'
      freq = get(block, 'freq');
      duty = get(block, 'square_duty');
      tsfcn = sprintf('square(2*pi*%f*t,%f)', eval(freq), eval(duty));
    case 'Sawtooth'
      freq  = get(block, 'freq');
      width = get(block, 'sawtooth_width');
      tsfcn = sprintf('sawtooth(2*pi*%f*t,%f)', eval(freq), eval(width));
  end
  pl = plist();
  pl = append(pl, param('tsfcn', tsfcn));
  params = string(pl);
else  
  error('### unknown parameter method for AO construction.');
end

%--------------------------------------------------------------------------
% Get parameters for plot block.
% 
function [params, pl] = get_plot_params(block)

pl = plist();

xscale = get(block, 'xscale');
yscale = get(block, 'yscale');

params = [];


%--------------------------------------------------------------------------
% Get parameters for ltpda_pwelch block.
% 
function [params, pl] = get_ltpda_pwelch_params(block)

pl = plist();

nfft    = get(block, 'Nfft');
nolap   = get(block, 'Nolap');

if isempty(nfft)
  nfft = 0;
else
  nfft = str2double(nfft);
end
if isempty(nolap)
  nolap = 0;
else
  nolap = str2double(nolap);
end

pl = plist();
if nfft > 0
  pl = append(pl, param('Nfft', nfft));
end
if nolap > 0
  pl = append(pl, param('Nolap', nolap));
end
params = string(pl);

%--------------------------------------------------------------------------
% Get parameters for ltpda_tfe block.
% 
function [params, pl] = get_ltpda_tfe_params(block)

winname = get(block, 'win');
nfft    = get(block, 'nfft');
nolap   = get(block, 'nolap');
psll    = get(block, 'psll');

if isempty(nfft)
  nfft = 0;
else
  nfft = str2double(nfft);
end
if isempty(nolap)
  nolap = 0;
else
  nolap = str2double(nolap);
end
if isempty(psll)
  psll = 0;
else
  psll = str2double(psll);
end

switch winname
  case 'Kaiser'
    if psll <=0 
      error('### ltpda_tfe block: please specify PSLL for Kaiser window.')
    end
    p = sprintf('specwin(''Kaiser'', %f, %f)', nfft, psll);
  case 'Hanning'
    p = sprintf('specwin(''Hanning'', %f)', nfft);
  otherwise
    error('### ltpda_tfe block: Unknown window name.');
end

pl = plist();
pl = append(pl, param('Nfft', nfft));
pl = append(pl, param('Win', eval(p)));
if nolap > 0
  pl = append(pl, param('Nolap', nolap));
end
params = string(pl);

%--------------------------------------------------------------------------
% Build command string
% 
function cmd = buildCmd(inames, onames, params, fcn)

cmd = '';

% add outputs
if ~isempty(onames)
  cmd = [cmd '['];
  for k=1:length(onames)
    cmd = [cmd onames{k} ','];
  end
  cmd = [cmd(1:end-1) ']'];
  cmd = [cmd ' = '];
end

% add fcn name
cmd = [cmd fcn];

% add inputs
cmd = [cmd '('];
if ~isempty(inames)
  for k=1:length(inames)
    cmd = [cmd inames{k} ','];
  end
end

% add parameters
if ~isempty(params)
  cmd = [cmd params];
else
  cmd = cmd(1:end-1);
end

cmd = [cmd ')'];
cmd = [cmd ';'];

%--------------------------------------------------------------------------
% get function name from block handle
function fcn = getFcnName(b)

blocktype = get(b, 'blocktype');
if ~strcmp(blocktype, 'Outport') && ~ strcmp(blocktype, 'Inport')
  name     = get(b, 'Name');
  masktype = get(b, 'MaskType');

  if isempty(masktype) && ~strcmp(blocktype, 'SubSystem')
    fcn = name;
  else
    fcn = masktype;
  end
  
  % Some overrides to this
  switch blocktype
    case 'Sum'
      fcn = 'plus';
    case 'Mux'
      fcn = 'mux';
    case 'Demux';
      fcn = 'demux';      
  end
  
  % Some function replacements
  switch fcn
    case 'plot'
      fcn = 'figure,plot';
    case 'filter'
      fcn = get(b, 'method');
    case 'convert'
      fcn = get(b, 'fcn');
    case 'iparam'
      fcn = 'param';
  end
  fcn = sltpda_fixvar(fcn);
end

%--------------------------------------------------------------------------
function [inames, onames] = getIOnames(myports, name)

% Get my inputs
inames = [];

ins = myports.Inport;
% get name of each input
for k=1:length(ins)
  ip = ins(k);
  lineState = get(ip, 'Line');
  pn = get(ip, 'PortNumber');
  if lineState == -1
    inames = [inames cellstr('[]')];
  else
    pstr = strrep([name '_in_' num2str(pn)], ' ', '_');
    pstr = sltpda_fixvar(pstr);
    inames = [inames cellstr(pstr)];
  end
end

% Get my outputs
onames = [];
outs = myports.Outport;
% get name of each output
for k=1:length(outs)
  op = outs(k);
  pn = get(op, 'PortNumber');
  pstr = strrep([name '_out_' num2str(pn)], ' ', '_');
  pstr = sltpda_fixvar(pstr);
  onames = [onames cellstr(pstr)];
end