/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2016-2022 CERN
 * Copyright (C) 2016-2023 KiCad Developers, see AUTHORS.txt for contributors.
 * @author Maciej Suminski <maciej.suminski@cern.ch>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * https://www.gnu.org/licenses/gpl-3.0.html
 * or you may search the http://www.gnu.org website for the version 3 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

#include "dialog_sim_command.h"
#include <sim/spice_circuit_model.h>
#include <sim/ngspice.h>
#include <sim/simulator_frame.h>
#include <sim/sim_plot_tab.h>
#include <confirm.h>

#include <wx/tokenzr.h>

#include <vector>
#include <utility>


// Helper function to shorten conditions
static bool empty( const wxTextEntryBase* aCtrl )
{
    return aCtrl->GetValue().IsEmpty();
}


static void setStringSelection( wxChoice* aCtrl, const wxString& aStr )
{
    aCtrl->SetSelection( aCtrl->FindString( aStr ) );
}


static wxString getStringSelection( const wxChoice* aCtrl )
{
    if( aCtrl->GetSelection() >= 0 )
        return aCtrl->GetString( aCtrl->GetSelection() );
    else
        return wxEmptyString;
}


DIALOG_SIM_COMMAND::DIALOG_SIM_COMMAND( SIMULATOR_FRAME* aParent,
                                        std::shared_ptr<SPICE_CIRCUIT_MODEL> aCircuitModel,
                                        std::shared_ptr<SPICE_SETTINGS>& aSettings ) :
        DIALOG_SIM_COMMAND_BASE( aParent ),
        m_simulatorFrame( aParent ),
        m_circuitModel( aCircuitModel ),
        m_settings( aSettings ),
        m_spiceEmptyValidator( true )
{
    m_simPages->Hide();

    m_posIntValidator.SetMin( 1 );

    m_acPointsNumber->SetValidator( m_posIntValidator );
    m_acFreqStart->SetValidator( m_spiceValidator );
    m_acFreqStop->SetValidator( m_spiceValidator );

    m_spPointsNumber->SetValidator( m_posIntValidator );
    m_spFreqStart->SetValidator( m_spiceValidator );
    m_spFreqStop->SetValidator( m_spiceValidator );

    m_dcStart1->SetValidator( m_spiceValidator );
    m_dcStop1->SetValidator( m_spiceValidator );
    m_dcIncr1->SetValidator( m_spiceValidator );

    m_dcStart2->SetValidator( m_spiceValidator );
    m_dcStop2->SetValidator( m_spiceValidator );
    m_dcIncr2->SetValidator( m_spiceValidator );

    m_noisePointsNumber->SetValidator( m_posIntValidator );
    m_noiseFreqStart->SetValidator( m_spiceValidator );
    m_noiseFreqStop->SetValidator( m_spiceValidator );

    m_transStep->SetValidator( m_spiceValidator );
    m_transFinal->SetValidator( m_spiceValidator );
    m_transInitial->SetValidator( m_spiceEmptyValidator );
    m_transMaxStep->SetValidator( m_spiceEmptyValidator );

    m_inputSignalsFilter->SetDescriptiveText( _( "Filter" ) );

    wxChar type1 = getStringSelection( m_dcSourceType1 ).Upper().GetChar( 0 );
    updateDCSources( type1, m_dcSource1 );

    wxChar type2 = getStringSelection( m_dcSourceType2 ).Upper().GetChar( 0 );
    updateDCSources( type2, m_dcSource2 );

    // NoiseRef is optional
    m_noiseRef->Append( wxEmptyString );

    for( const std::string& net : m_circuitModel->GetNets() )
    {
        m_pzInput->Append( net );
        m_pzInputRef->Append( net );
        m_pzOutput->Append( net );
        m_pzOutputRef->Append( net );

        m_noiseMeas->Append( net );
        m_noiseRef->Append( net );
    }

    for( const SPICE_ITEM& item : m_circuitModel->GetItems() )
    {
        if( item.model->GetDeviceType() == SIM_MODEL::DEVICE_T::V )
            m_noiseSrc->Append( item.refName );
    }

    if( !dynamic_cast<NGSPICE_SETTINGS*>( aSettings.get() ) )
        m_compatibilityModeSizer->Show( false );

    int minWidth = GetTextExtent( wxS( "XXX.XXXXXXX" ) ).x;
    m_y1Min->SetMinSize( wxSize( minWidth, -1 ) );
    m_y1Max->SetMinSize( wxSize( minWidth, -1 ) );
    m_y2Min->SetMinSize( wxSize( minWidth, -1 ) );
    m_y2Max->SetMinSize( wxSize( minWidth, -1 ) );
    m_y3Min->SetMinSize( wxSize( minWidth, -1 ) );
    m_y3Max->SetMinSize( wxSize( minWidth, -1 ) );

    m_bSizerY1->Show( false );
    m_bSizerY2->Show( false );
    m_bSizerY3->Show( false );

    SetupStandardButtons();
}

bool DIALOG_SIM_COMMAND::TransferDataToWindow()
{
    /// @todo one day it could interpret the sim command and fill out appropriate fields.
    if( empty( m_customTxt ) )
        loadDirectives();

    m_fixIncludePaths->SetValue( m_settings->GetFixIncludePaths() );

    if( NGSPICE_SETTINGS* settings = dynamic_cast<NGSPICE_SETTINGS*>( m_settings.get() ) )
    {
        switch( settings->GetCompatibilityMode() )
        {
        case NGSPICE_COMPATIBILITY_MODE::USER_CONFIG: m_compatibilityMode->SetSelection( 0 ); break;
        case NGSPICE_COMPATIBILITY_MODE::NGSPICE:     m_compatibilityMode->SetSelection( 1 ); break;
        case NGSPICE_COMPATIBILITY_MODE::PSPICE:      m_compatibilityMode->SetSelection( 2 ); break;
        case NGSPICE_COMPATIBILITY_MODE::LTSPICE:     m_compatibilityMode->SetSelection( 3 ); break;
        case NGSPICE_COMPATIBILITY_MODE::LT_PSPICE:   m_compatibilityMode->SetSelection( 4 ); break;
        case NGSPICE_COMPATIBILITY_MODE::HSPICE:      m_compatibilityMode->SetSelection( 5 ); break;
        default:    wxFAIL_MSG( wxString::Format( "Unknown NGSPICE_COMPATIBILITY_MODE %d.",
                                                  settings->GetCompatibilityMode() ) );       break;
        }
    }

    return true;
}


void DIALOG_SIM_COMMAND::OnUpdateUILockY1( wxUpdateUIEvent& event )
{
    event.Enable( m_lockY1->GetValue() );
}


void DIALOG_SIM_COMMAND::OnUpdateUILockY2( wxUpdateUIEvent& event )
{
    event.Enable( m_lockY2->GetValue() );
}


void DIALOG_SIM_COMMAND::OnUpdateUILockY3( wxUpdateUIEvent& event )
{
    event.Enable( m_lockY3->GetValue() );
}


void DIALOG_SIM_COMMAND::SetPlotSettings( const SIM_TAB* aSimTab )
{
    if( const SIM_PLOT_TAB* plotTab = dynamic_cast<const SIM_PLOT_TAB*>( aSimTab ) )
    {
        if( !plotTab->GetLabelY1().IsEmpty() )
        {
            m_bSizerY1->Show( true );
            m_lockY1->SetLabel( wxString::Format( m_lockY1->GetLabel(), plotTab->GetLabelY1() ) );
            m_y1Units->SetLabel( plotTab->GetUnitsY1() );

            double min, max;
            bool   locked = plotTab->GetY1Scale( &min, &max );
            m_lockY1->SetValue( locked );

            if( !std::isnan( min ) )
                m_y1Min->SetValue( SIM_VALUE::Normalize( min ) );

            if( !std::isnan( max ) )
                m_y1Max->SetValue( SIM_VALUE::Normalize( max ) );
        }

        if( !plotTab->GetLabelY2().IsEmpty() )
        {
            m_bSizerY2->Show( true );
            m_lockY2->SetLabel( wxString::Format( m_lockY2->GetLabel(), plotTab->GetLabelY2() ) );
            m_y2Units->SetLabel( plotTab->GetUnitsY2() );

            double min, max;
            bool   locked = plotTab->GetY2Scale( &min, &max );
            m_lockY2->SetValue( locked );

            if( !std::isnan( min ) )
                m_y2Min->SetValue( SIM_VALUE::Normalize( min ) );

            if( !std::isnan( max ) )
                m_y2Max->SetValue( SIM_VALUE::Normalize( max ) );
        }

        if( !plotTab->GetLabelY3().IsEmpty() )
        {
            m_bSizerY3->Show( true );
            m_lockY3->SetLabel( wxString::Format( m_lockY3->GetLabel(), plotTab->GetLabelY3() ) );
            m_y3Units->SetLabel( plotTab->GetUnitsY3() );

            double min, max;
            bool   locked = plotTab->GetY3Scale( &min, &max );
            m_lockY3->SetValue( locked );

            if( !std::isnan( min ) )
                m_y3Min->SetValue( SIM_VALUE::Normalize( min ) );

            if( !std::isnan( max ) )
                m_y3Max->SetValue( SIM_VALUE::Normalize( max ) );
        }

        m_grid->SetValue( plotTab->IsGridShown() );
        m_legend->SetValue( plotTab->IsLegendShown() );
        m_dottedSecondary->SetValue( plotTab->GetDottedSecondary() );

#define GET_STR( val ) EDA_UNIT_UTILS::UI::MessageTextFromValue( unityScale, EDA_UNITS::UNSCALED, \
                                                                 val, false /* no units */ )

        m_marginLeft->SetValue( GET_STR( plotTab->GetPlotWin()->GetMarginLeft() ) );
        m_marginTop->SetValue( GET_STR( plotTab->GetPlotWin()->GetMarginTop() ) );
        m_marginRight->SetValue( GET_STR( plotTab->GetPlotWin()->GetMarginRight() ) );
        m_marginBottom->SetValue( GET_STR( plotTab->GetPlotWin()->GetMarginBottom() ) );
    }
}


wxString DIALOG_SIM_COMMAND::evaluateDCControls( wxChoice* aDcSource, wxTextCtrl* aDcStart,
                                                 wxTextCtrl* aDcStop, wxTextCtrl* aDcIncr )
{
    wxString  dcSource;
    wxWindow* ctrlWithError = nullptr;

    if( aDcSource->GetSelection() >= 0 )
        dcSource = aDcSource->GetString( aDcSource->GetSelection() );

    if( dcSource.IsEmpty() )
    {
        DisplayError( this, _( "A DC source must be specified." ) );
        ctrlWithError = aDcSource;
    }
    else if( !aDcStart->Validate() )
        ctrlWithError = aDcStart;
    else if( !aDcStop->Validate() )
        ctrlWithError = aDcStop;
    else if( !aDcIncr->Validate() )
        ctrlWithError = aDcIncr;

    if( ctrlWithError )
    {
        ctrlWithError->SetFocus();
        return wxEmptyString;
    }

    // pick device name from exporter when something different than temperature is selected
    if( dcSource.Cmp( "TEMP" ) )
        dcSource = m_circuitModel->GetItemName( std::string( dcSource.ToUTF8() ) );

    return wxString::Format( "%s %s %s %s", dcSource,
                             SPICE_VALUE( aDcStart->GetValue() ).ToSpiceString(),
                             SPICE_VALUE( aDcStop->GetValue() ).ToSpiceString(),
                             SPICE_VALUE( aDcIncr->GetValue() ).ToSpiceString() );
}


bool DIALOG_SIM_COMMAND::TransferDataFromWindow()
{
    if( !wxDialog::TransferDataFromWindow() )
        return false;

    // The simulator dependent settings always get transferred.
    if( NGSPICE_SETTINGS* settings = dynamic_cast<NGSPICE_SETTINGS*>( m_settings.get() ) )
    {
        switch( m_compatibilityMode->GetSelection() )
        {
        case 0: settings->SetCompatibilityMode( NGSPICE_COMPATIBILITY_MODE::USER_CONFIG ); break;
        case 1: settings->SetCompatibilityMode( NGSPICE_COMPATIBILITY_MODE::NGSPICE );     break;
        case 2: settings->SetCompatibilityMode( NGSPICE_COMPATIBILITY_MODE::PSPICE );      break;
        case 3: settings->SetCompatibilityMode( NGSPICE_COMPATIBILITY_MODE::LTSPICE );     break;
        case 4: settings->SetCompatibilityMode( NGSPICE_COMPATIBILITY_MODE::LT_PSPICE );   break;
        case 5: settings->SetCompatibilityMode( NGSPICE_COMPATIBILITY_MODE::HSPICE );      break;
        }
    }

    wxString previousSimCommand = m_simCommand;
    wxWindow* page = m_simPages->GetCurrentPage();

    if( page == m_pgAC )                // AC small-signal analysis
    {
        if( !m_pgAC->Validate() )
            return false;

        m_simCommand.Printf( ".ac %s %s %s %s",
                             scaleToString( m_acScale->GetSelection() ),
                             m_acPointsNumber->GetValue(),
                             SPICE_VALUE( m_acFreqStart->GetValue() ).ToSpiceString(),
                             SPICE_VALUE( m_acFreqStop->GetValue() ).ToSpiceString() );
    }
    else if( page == m_pgSP )           // S-params analysis
    {
        if( !m_pgSP->Validate() )
            return false;

        m_simCommand.Printf( ".sp %s %s %s %s %s", scaleToString( m_spScale->GetSelection() ),
                             m_spPointsNumber->GetValue(),
                             SPICE_VALUE( m_spFreqStart->GetValue() ).ToSpiceString(),
                             SPICE_VALUE( m_spFreqStop->GetValue() ).ToSpiceString(),
                             m_spDoNoise ? "1" : "" );
    }
    else if( page == m_pgDC )           // DC transfer analysis
    {
        wxString simCmd = wxString( ".dc " );

        wxString src1 = evaluateDCControls( m_dcSource1, m_dcStart1, m_dcStop1, m_dcIncr1 );

        if( src1.IsEmpty() )
            return false;
        else
            simCmd += src1;

        if( m_dcEnable2->IsChecked() )
        {
            wxString src2 = evaluateDCControls( m_dcSource2, m_dcStart2, m_dcStop2, m_dcIncr2 );

            if( src2.IsEmpty() )
                return false;
            else
                simCmd += " " + src2;

            if( m_dcSource1->GetStringSelection() == m_dcSource2->GetStringSelection() )
            {
                DisplayError( this, _( "Source 1 and Source 2 must be different." ) );
                return false;
            }
        }

        m_simCommand = simCmd;
    }
    else if( page == m_pgFFT )          // Fast Fourier transform
    {
        m_simCommand = wxEmptyString;
        wxString vectors;

        for( int ii = 0; ii < (int) m_inputSignalsList->GetCount(); ++ii )
        {
            if( m_inputSignalsList->IsChecked( ii ) )
                vectors += wxS( " " ) + m_inputSignalsList->GetString( ii );
        }

        if( m_linearize->IsChecked() )
            m_simCommand = wxT( "linearize" ) + vectors + wxS( "\n" );

        m_simCommand += wxT( "fft" ) + vectors;
    }
    else if( page == m_pgPZ )           // Pole-zero analyses
    {
        wxString input = m_pzInput->GetStringSelection();
        wxString inputRef = m_pzInputRef->GetStringSelection();
        wxString output = m_pzOutput->GetStringSelection();
        wxString outputRef = m_pzOutputRef->GetStringSelection();
        wxString transferFunction = wxS( "vol" );
        wxString analyses = wxS( "pz" );

        if( m_pzFunctionType->GetSelection() == 1 )
            transferFunction = wxS( "cur" );

        if( m_pzAnalyses->GetSelection() == 1 )
            analyses = wxS( "pol" );
        else if( m_pzAnalyses->GetSelection() == 2 )
            analyses = wxS( "zer" );

        m_simCommand.Printf( ".pz %s %s %s %s %s %s",
                             input,
                             inputRef,
                             output,
                             outputRef,
                             transferFunction,
                             analyses );
    }
    else if( page == m_pgNOISE )        // Noise analysis
    {
        wxString output = m_noiseMeas->GetStringSelection();
        wxString ref = m_noiseRef->GetStringSelection();
        wxString noiseSource = m_noiseSrc->GetStringSelection();

        if( m_noiseFreqStart->IsEmpty() || m_noiseFreqStop->IsEmpty() )
        {
            DisplayError( this, _( "A frequency range must be specified." ) );
            return false;
        }

        if( !ref.IsEmpty() )
            ref = wxS( "," ) + m_circuitModel->GetItemName( std::string( ref.ToUTF8() ) );

        m_simCommand.Printf( ".noise v(%s%s) %s %s %s %s %s %s",
                             output,
                             ref,
                             noiseSource,
                             scaleToString( m_noiseScale->GetSelection() ),
                             m_noisePointsNumber->GetValue(),
                             SPICE_VALUE( m_noiseFreqStart->GetValue() ).ToSpiceString(),
                             SPICE_VALUE( m_noiseFreqStop->GetValue() ).ToSpiceString(),
                             m_saveAllNoise->GetValue() ? "1" : "" );
    }
    else if( page == m_pgOP )           // DC operating point analysis
    {
        m_simCommand = wxString( ".op" );
    }
    else if( page == m_pgTRAN )         // Transient analysis
    {
        if( !m_pgTRAN->Validate() )
            return false;

        const wxString    spc = wxS( " " );
        const SPICE_VALUE timeStep( m_transStep->GetValue() );
        const SPICE_VALUE finalTime( m_transFinal->GetValue() );

        SPICE_VALUE startTime( 0 );

        if( !empty( m_transInitial ) )
            startTime = SPICE_VALUE( m_transInitial->GetValue() );

        wxString optionals;

        if( m_useInitialConditions->GetValue() )
            optionals = wxS( "uic" );

        if( !empty( m_transMaxStep ) )
        {
            optionals = SPICE_VALUE( m_transMaxStep->GetValue() ).ToSpiceString() + spc + optionals;
        }
        else if( !optionals.IsEmpty() )
        {
            SPICE_VALUE maxStep = ( finalTime - startTime ) / 50.0;

            if( maxStep > timeStep )
                maxStep = timeStep;

            optionals = maxStep.ToSpiceString() + spc + optionals;
        }

        if( !empty( m_transInitial ) )
            optionals = startTime.ToSpiceString() + spc + optionals;
        else if( !optionals.IsEmpty() )
            optionals = wxS( "0 " ) + optionals;

        m_simCommand.Printf( wxS( ".tran %s %s %s" ), timeStep.ToSpiceString(),
                             finalTime.ToSpiceString(), optionals );
    }
    else if( page == m_pgCustom )       // Custom directives
    {
        m_simCommand = m_customTxt->GetValue();
    }
    else
    {
        return false;
    }

    if( previousSimCommand != m_simCommand )
        m_simCommand.Trim();

    m_settings->SetFixIncludePaths( m_fixIncludePaths->GetValue() );

    return true;
}


void DIALOG_SIM_COMMAND::ApplySettings( SIM_TAB* aTab )
{
    int options = NETLIST_EXPORTER_SPICE::OPTION_DEFAULT_FLAGS;

    if( !m_fixIncludePaths->GetValue() )
        options &= ~NETLIST_EXPORTER_SPICE::OPTION_ADJUST_INCLUDE_PATHS;

    if( !m_saveAllVoltages->GetValue() )
        options &= ~NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_VOLTAGES;

    if( !m_saveAllCurrents->GetValue() )
        options &= ~NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_CURRENTS;

    if( !m_saveAllDissipations->GetValue() )
        options &= ~NETLIST_EXPORTER_SPICE::OPTION_SAVE_ALL_DISSIPATIONS;

    aTab->SetSimOptions( options );
    m_simulatorFrame->ReloadSimulator( m_simCommand, options );

#define TO_INT( ctrl ) (int) EDA_UNIT_UTILS::UI::ValueFromString( unityScale, EDA_UNITS::UNSCALED, \
                                                                  ctrl->GetValue() )

    if( SIM_PLOT_TAB* plotTab = dynamic_cast<SIM_PLOT_TAB*>( aTab ) )
    {
        if( !plotTab->GetLabelY1().IsEmpty() )
        {
            plotTab->SetY1Scale( m_lockY1->GetValue(),
                                 SIM_VALUE::ToDouble( m_y1Min->GetValue().ToStdString() ),
                                 SIM_VALUE::ToDouble( m_y1Max->GetValue().ToStdString() ) );
        }

        if( !plotTab->GetLabelY2().IsEmpty() )
        {
            plotTab->SetY2Scale( m_lockY2->GetValue(),
                                 SIM_VALUE::ToDouble( m_y2Min->GetValue().ToStdString() ),
                                 SIM_VALUE::ToDouble( m_y2Max->GetValue().ToStdString() ) );
        }

        if( !plotTab->GetLabelY3().IsEmpty() )
        {
            plotTab->SetY3Scale( m_lockY3->GetValue(),
                                 SIM_VALUE::ToDouble( m_y3Min->GetValue().ToStdString() ),
                                 SIM_VALUE::ToDouble( m_y3Max->GetValue().ToStdString() ) );
        }

        plotTab->GetPlotWin()->LockY( m_lockY1->GetValue()
                                      || m_lockY2->GetValue()
                                      || m_lockY3->GetValue() );

        plotTab->ShowGrid( m_grid->GetValue() );
        plotTab->ShowLegend( m_legend->GetValue() );
        plotTab->SetDottedSecondary( m_dottedSecondary->GetValue() );

        plotTab->GetPlotWin()->SetMarginLeft( TO_INT( m_marginLeft ) );
        plotTab->GetPlotWin()->SetMarginRight( TO_INT( m_marginRight ) );
        plotTab->GetPlotWin()->SetMarginTop( TO_INT( m_marginTop ) );
        plotTab->GetPlotWin()->SetMarginBottom( TO_INT( m_marginBottom ) );

        plotTab->GetPlotWin()->AdjustLimitedView();
        plotTab->GetPlotWin()->UpdateAll();
    }
}


void DIALOG_SIM_COMMAND::updateDCSources( wxChar aType, wxChoice* aSource )
{
    wxString prevSelection;

    if( !aSource->IsEmpty() )
        prevSelection = aSource->GetString( aSource->GetSelection() );

    std::set<wxString> sourcesList;
    bool               enableSrcSelection = true;

    if( aType != 'T' )
    {
        for( const SPICE_ITEM& item : m_circuitModel->GetItems() )
        {
            if( ( aType == 'R' && item.model->GetDeviceType() == SIM_MODEL::DEVICE_T::R )
            ||  ( aType == 'V' && item.model->GetDeviceType() == SIM_MODEL::DEVICE_T::V )
            ||  ( aType == 'I' && item.model->GetDeviceType() == SIM_MODEL::DEVICE_T::I ) )
            {
                sourcesList.insert( item.refName );
            }
        }

        if( aSource == m_dcSource2 && !m_dcEnable2->IsChecked() )
            enableSrcSelection = false;
    }
    else
    {
        prevSelection = wxT( "TEMP" );
        sourcesList.insert( prevSelection );
        enableSrcSelection = false;
    }

    aSource->Enable( enableSrcSelection );

    aSource->Clear();

    for( const wxString& src : sourcesList )
        aSource->Append( src );

    // Try to restore the previous selection, if possible
    aSource->SetStringSelection( prevSelection );
}


void DIALOG_SIM_COMMAND::parseCommand( const wxString& aCommand )
{
    if( aCommand.IsEmpty() )
        return;

    if( aCommand == wxT( "*" ) )
    {
        SetTitle( _( "New Simulation Tab" ) );

        m_commandType->Clear();

        for( SIM_TYPE type : { ST_OP, ST_DC, ST_AC, ST_TRAN, ST_PZ, ST_NOISE, ST_SP, ST_FFT } )
        {
            m_commandType->Append( SPICE_SIMULATOR::TypeToName( type, true )
                                        + wxT( "  \u2014  " )
                                        + SPICE_SIMULATOR::TypeToName( type, false ) );
        }

        m_commandTypeSizer->Show( true );
        m_commandType->SetSelection( 0 );
        m_simPages->SetSelection( m_simPages->FindPage( m_pgOP ) );
        m_simPages->Show();
        return;
    }

    SIM_TYPE simType = SPICE_CIRCUIT_MODEL::CommandToSimType( aCommand );

    SetTitle( SPICE_SIMULATOR::TypeToName( simType, true )
                    + wxT( "  \u2014  " )
                    + SPICE_SIMULATOR::TypeToName( simType, false ) );

    m_commandTypeSizer->Show( false );

    wxStringTokenizer tokenizer( aCommand, wxS( " \t\n\r" ), wxTOKEN_STRTOK );
    wxString          token = tokenizer.GetNextToken().Lower();

    switch( simType )
    {
    case ST_AC:
        m_simPages->SetSelection( m_simPages->FindPage( m_pgAC ) );

        token = tokenizer.GetNextToken().Lower();

        for( SCALE_TYPE candidate : { DECADE, OCTAVE, LINEAR } )
        {
            if( scaleToString( candidate ) == token )
            {
                m_acScale->SetSelection( candidate );
                break;
            }
        }

        m_acPointsNumber->SetValue( tokenizer.GetNextToken() );
        m_acFreqStart->SetValue( SPICE_VALUE( tokenizer.GetNextToken() ).ToSpiceString() );
        m_acFreqStop->SetValue( SPICE_VALUE( tokenizer.GetNextToken() ).ToSpiceString() );
        break;

    case ST_SP:
        m_simPages->SetSelection( m_simPages->FindPage( m_pgSP ) );

        token = tokenizer.GetNextToken().Lower();

        for( SCALE_TYPE candidate : { DECADE, OCTAVE, LINEAR } )
        {
            if( scaleToString( candidate ) == token )
            {
                m_spScale->SetSelection( candidate );
                break;
            }
        }

        m_spPointsNumber->SetValue( tokenizer.GetNextToken() );
        m_spFreqStart->SetValue( SPICE_VALUE( tokenizer.GetNextToken() ).ToSpiceString() );
        m_spFreqStop->SetValue( SPICE_VALUE( tokenizer.GetNextToken() ).ToSpiceString() );

	    if( tokenizer.HasMoreTokens() )
            m_spDoNoise->SetValue( SPICE_VALUE( tokenizer.GetNextToken() ).ToSpiceString() == "1" );

        break;

    case ST_DC:
    {
        m_simPages->SetSelection( m_simPages->FindPage( m_pgDC ) );

        SPICE_DC_PARAMS src1, src2;
        src2.m_vincrement = SPICE_VALUE( -1 );

        m_circuitModel->ParseDCCommand( aCommand, &src1, &src2 );

        if( src1.m_source.IsSameAs( wxT( "TEMP" ), false ) )
            setStringSelection( m_dcSourceType1, wxT( "TEMP" ) );
        else
            setStringSelection( m_dcSourceType1, src1.m_source.GetChar( 0 ) );

        updateDCSources( src1.m_source.GetChar( 0 ), m_dcSource1 );
        m_dcSource1->SetStringSelection( src1.m_source );
        m_dcStart1->SetValue( src1.m_vstart.ToSpiceString() );
        m_dcStop1->SetValue( src1.m_vend.ToSpiceString() );
        m_dcIncr1->SetValue( src1.m_vincrement.ToSpiceString() );

        if( src2.m_vincrement.ToDouble() != -1 )
        {
            if( src2.m_source.IsSameAs( wxT( "TEMP" ), false ) )
                setStringSelection( m_dcSourceType2, wxT( "TEMP" ) );
            else
                setStringSelection( m_dcSourceType2, src2.m_source.GetChar( 0 ) );

            updateDCSources( src2.m_source.GetChar( 0 ), m_dcSource2 );
            m_dcSource2->SetStringSelection( src2.m_source );
            m_dcStart2->SetValue( src2.m_vstart.ToSpiceString() );
            m_dcStop2->SetValue( src2.m_vend.ToSpiceString() );
            m_dcIncr2->SetValue( src2.m_vincrement.ToSpiceString() );

            m_dcEnable2->SetValue( true );
        }

        break;
    }

    case ST_PZ:
    {
        m_simPages->SetSelection( m_simPages->FindPage( m_pgPZ ) );

        wxString          transferFunction;
        wxString          input, inputRef;
        wxString          output, outputRef;
        SPICE_PZ_ANALYSES analyses;

        m_circuitModel->ParsePZCommand( aCommand, &transferFunction, &input, &inputRef, &output,
                                        &outputRef, &analyses );

        m_pzInput->SetStringSelection( input );
        m_pzInputRef->SetStringSelection( inputRef );
        m_pzOutput->SetStringSelection( output );
        m_pzOutputRef->SetStringSelection( outputRef );

        m_pzFunctionType->SetSelection( transferFunction.Lower() == "cur" ? 1 : 0 );

        if( analyses.m_Poles && analyses.m_Zeros )
            m_pzAnalyses->SetSelection( 0 );
        else if( analyses.m_Poles )
            m_pzAnalyses->SetSelection( 1 );
        else
            m_pzAnalyses->SetSelection( 2 );

        break;
    }

    case ST_NOISE:
    {
        m_simPages->SetSelection( m_simPages->FindPage( m_pgNOISE ) );

        wxString    output;
        wxString    ref;
        wxString    source;
        wxString    scale;
        SPICE_VALUE pts;
        SPICE_VALUE fStart;
        SPICE_VALUE fStop;
        bool        saveAll;

        m_circuitModel->ParseNoiseCommand( aCommand, &output, &ref, &source, &scale, &pts,
                                           &fStart, &fStop, &saveAll );

        m_noiseMeas->SetStringSelection( output );
        m_noiseRef->SetStringSelection( ref );
        m_noiseSrc->SetStringSelection( source );

        for( SCALE_TYPE candidate : { DECADE, OCTAVE, LINEAR } )
        {
            if( scaleToString( candidate ) == scale )
            {
                m_noiseScale->SetSelection( candidate );
                break;
            }
        }

        m_noisePointsNumber->SetValue( pts.ToSpiceString() );
        m_noiseFreqStart->SetValue( fStart.ToSpiceString() );
        m_noiseFreqStop->SetValue( fStop.ToSpiceString() );

        m_saveAllNoise->SetValue( saveAll );
        break;
    }

    case ST_TRAN:
        m_simPages->SetSelection( m_simPages->FindPage( m_pgTRAN ) );

        // If the fields below are empty, it will be caught by the exception handler
        m_transStep->SetValue( SPICE_VALUE( tokenizer.GetNextToken() ).ToSpiceString() );
        m_transFinal->SetValue( SPICE_VALUE( tokenizer.GetNextToken() ).ToSpiceString() );

        // Initial time is an optional field
        token = tokenizer.GetNextToken();

        if( !token.IsEmpty() )
            m_transInitial->SetValue( SPICE_VALUE( token ).ToSpiceString() );

        // Max step is an optional field
        token = tokenizer.GetNextToken();

        if( !token.IsEmpty() )
            m_transMaxStep->SetValue( SPICE_VALUE( token ).ToSpiceString() );

        // uic is an optional field
        token = tokenizer.GetNextToken();

        if( token.IsSameAs( wxS( "uic" ) ) )
            m_useInitialConditions->SetValue( true );

        break;

    case ST_OP:
        m_simPages->SetSelection( m_simPages->FindPage( m_pgOP ) );
        break;

    case ST_FFT:
    {
        m_simPages->SetSelection( m_simPages->FindPage( m_pgFFT ) );

        while( tokenizer.HasMoreTokens() )
            m_fftInputSignals.insert( tokenizer.GetNextToken() );

        break;
    }

    default:
        m_simPages->SetSelection( m_simPages->FindPage( m_pgCustom ) );
        break;
    }

    m_simPages->Show();
}


void DIALOG_SIM_COMMAND::OnCommandType( wxCommandEvent& event )
{
    int      sel = ST_UNKNOWN;
    wxString str = m_commandType->GetString( event.GetSelection() );

    for( int type = ST_UNKNOWN; type < ST_LAST; ++type )
    {
        if( str.StartsWith( SPICE_SIMULATOR::TypeToName( (SIM_TYPE) type, true ) ) )
            sel = type;
    }

    switch( sel )
    {
    case ST_AC:    m_simPages->SetSelection( m_simPages->FindPage( m_pgAC ) );     break;
    case ST_SP:    m_simPages->SetSelection( m_simPages->FindPage( m_pgSP ) );     break;
    case ST_DC:    m_simPages->SetSelection( m_simPages->FindPage( m_pgDC ) );     break;
    case ST_PZ:    m_simPages->SetSelection( m_simPages->FindPage( m_pgPZ ) );     break;
    case ST_NOISE: m_simPages->SetSelection( m_simPages->FindPage( m_pgNOISE ) );  break;
    case ST_TRAN:  m_simPages->SetSelection( m_simPages->FindPage( m_pgTRAN ) );   break;
    case ST_OP:    m_simPages->SetSelection( m_simPages->FindPage( m_pgOP ) );     break;
    case ST_FFT:   m_simPages->SetSelection( m_simPages->FindPage( m_pgFFT ) );    break;
    default:       m_simPages->SetSelection( m_simPages->FindPage( m_pgCustom ) ); break;
    }
}


void DIALOG_SIM_COMMAND::onSwapDCSources( wxCommandEvent& event )
{
    std::vector<std::pair<wxTextEntry*, wxTextEntry*>> textCtrl = { { m_dcStart1, m_dcStart2 },
                                                                    { m_dcStop1, m_dcStop2 },
                                                                    { m_dcIncr1, m_dcIncr2 } };

    for( auto& couple : textCtrl )
    {
        wxString tmp = couple.first->GetValue();
        couple.first->SetValue( couple.second->GetValue() );
        couple.second->SetValue( tmp );
    }

    int src1 = m_dcSource1->GetSelection();
    int src2 = m_dcSource2->GetSelection();

    int sel = m_dcSourceType1->GetSelection();
    m_dcSourceType1->SetSelection( m_dcSourceType2->GetSelection() );
    m_dcSourceType2->SetSelection( sel );

    wxChar type1 = getStringSelection( m_dcSourceType1 ).Upper().GetChar( 0 );
    updateDCSources( type1, m_dcSource1 );
    wxChar type2 = getStringSelection( m_dcSourceType2 ).Upper().GetChar( 0 );
    updateDCSources( type2, m_dcSource2 );

    m_dcSource1->SetSelection( src2 );
    m_dcSource2->SetSelection( src1 );

    updateDCUnits( type1, m_src1DCStartValUnit, m_src1DCEndValUnit, m_src1DCStepUnit );
    updateDCUnits( type2, m_src2DCStartValUnit, m_src2DCEndValUnit, m_src2DCStepUnit );
}


void DIALOG_SIM_COMMAND::onDCSource1Selected( wxCommandEvent& event )
{
    wxChar type = m_dcSourceType1->GetString( m_dcSourceType1->GetSelection() ).Upper()[ 0 ];
    updateDCSources( type, m_dcSource1 );
    updateDCUnits( type, m_src1DCStartValUnit, m_src1DCEndValUnit, m_src1DCStepUnit );
}


void DIALOG_SIM_COMMAND::onDCSource2Selected( wxCommandEvent& event )
{
    wxChar type = m_dcSourceType2->GetString( m_dcSourceType2->GetSelection() ).Upper()[ 0 ];
    updateDCSources( type, m_dcSource2 );
    updateDCUnits( type, m_src2DCStartValUnit, m_src2DCEndValUnit, m_src2DCStepUnit );
}


void DIALOG_SIM_COMMAND::onDCEnableSecondSource( wxCommandEvent& event )
{
    bool   is2ndSrcEnabled = m_dcEnable2->IsChecked();
    wxChar type = '?';

    if( is2ndSrcEnabled )
    {
        wxString fullType = getStringSelection( m_dcSourceType2 ).Upper();

        if( fullType.Length() > 0 )
            type = fullType.GetChar( 0 );
    }

    m_dcSourceType2->Enable( is2ndSrcEnabled );
    m_dcSource2->Enable( is2ndSrcEnabled && type != 'T' );
    m_dcStart2->Enable( is2ndSrcEnabled );
    m_dcStop2->Enable( is2ndSrcEnabled );
    m_dcIncr2->Enable( is2ndSrcEnabled );
}


void DIALOG_SIM_COMMAND::updateDCUnits( wxChar aType, wxStaticText* aStartValUnit,
                                        wxStaticText* aEndValUnit, wxStaticText* aStepUnit )
{
    wxString unit;

    switch( aType )
    {
    case 'V': unit = wxS( "V" );  break;
    case 'I': unit = wxS( "A" );  break;
    case 'R': unit = wxS( "Ω" );  break;
    case 'T': unit = wxS( "°C" ); break;
    }

    aStartValUnit->SetLabel( unit );
    aEndValUnit->SetLabel( unit );
    aStepUnit->SetLabel( unit );

    m_pgDC->Refresh();
}


void DIALOG_SIM_COMMAND::loadDirectives()
{
    if( m_circuitModel )
        m_customTxt->SetValue( m_circuitModel->GetSchTextSimCommand() );
}


void DIALOG_SIM_COMMAND::OnFilterText( wxCommandEvent& aEvent )
{
    for( int ii = 0; ii < (int) m_inputSignalsList->GetCount(); ++ii )
    {
        if( m_inputSignalsList->IsChecked( ii ) )
            m_fftInputSignals.insert( m_inputSignalsList->GetString( ii ) );
        else
            m_fftInputSignals.erase( m_inputSignalsList->GetString( ii ) );
    }

    m_inputSignalsList->Clear();

    wxString aFilter = m_inputSignalsFilter->GetValue();

    if( aFilter.IsEmpty() )
        aFilter = wxS( "*" );

    EDA_COMBINED_MATCHER matcher( aFilter.Upper(), CTX_SIGNAL );

    for( const wxString& signal : m_simulatorFrame->Signals() )
    {
        if( matcher.Find( signal.Upper() ) )
        {
            m_inputSignalsList->Append( signal );

            if( m_fftInputSignals.count( signal ) )
                m_inputSignalsList->Check( m_inputSignalsList->GetCount() - 1 );
        }
    }
}


void DIALOG_SIM_COMMAND::OnFilterMouseMoved( wxMouseEvent& aEvent )
{
    wxPoint pos = aEvent.GetPosition();
    wxRect  ctrlRect = m_inputSignalsFilter->GetScreenRect();
    int     buttonWidth = ctrlRect.GetHeight();         // Presume buttons are square

    if( m_inputSignalsFilter->IsSearchButtonVisible() && pos.x < buttonWidth )
        SetCursor( wxCURSOR_ARROW );
    else if( m_inputSignalsFilter->IsCancelButtonVisible() && pos.x > ctrlRect.GetWidth() - buttonWidth )
        SetCursor( wxCURSOR_ARROW );
    else
        SetCursor( wxCURSOR_IBEAM );
}