/**
 * @file wizard_add_fplib.cpp
 */

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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 2
 * 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:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

/** @brief this code creates a wizard to add entries in the footprint library table.
 * The wizard contains 3 pages:
 * The first is the selection of the type of libraries (plugin type):
 *  * Kicad .pretty library (actually a folder containing .kicad_mod footprint files)
 *  * Gihtub .pretty on line library, accessible via a internet connection
 *  * Legacy library (old .mod format file containing footprints desc)
 *  * Eagle xml V6 library (.lbr files)
 *  * Geda-PCB library (actually a folder containing .fp footprint files
 * The second is the selection of path management:
 *  use environment variable or absolute path.
 *  When using an environment variable, selec it
 * The third is the library list selection
 *  It allows entering entries by running a tool to select a set of libraries
 *  The tool depend on the type of lib (files/folder/urls):
 *    * multi files selector
 *    * multi folder selector
 *    * multi URL selector (via a web viewer)
 * The path and the plugin type comes from the selection, and a library nickname
 * is built from the path.
 */

#include <wx/wx.h>
#include <wx/url.h>
#include <wx/progdlg.h>

#include <pgm_base.h>
#include <kiface_i.h>
#include <dialog_helpers.h>
#include <project.h>        // For PROJECT_VAR_NAME definition
#include <fp_lib_table.h>   // For KISYSMOD definition
#include <io_mgr.h>
#include <wizard_add_fplib.h>
#include <dialog_select_dirlist_base.h>

// a key to store the default Kicad Github libs URL
#define KICAD_FPLIBS_URL_KEY wxT( "kicad_fplib_url" )

// key to store last options of th wizard
#define WIZARD_LAST_PLUGIN_KEY wxT( "wizard_plugin" )
#define WIZARD_LAST_PATHOPTION_KEY wxT( "wizard_path_option" )

// static members to store last choices during a session
int WIZARD_FPLIB_TABLE::m_last_plugin_choice = 0;
int WIZARD_FPLIB_TABLE::m_last_defaultpath_choice = 2;

WIZARD_FPLIB_TABLE::WIZARD_FPLIB_TABLE( wxWindow* aParent, wxArrayString& aEnvVariableList )
        : WIZARD_FPLIB_TABLE_BASE( aParent )
{
    initDlg( aEnvVariableList );

    // Allows github plugin selection only when the plugin is compiled:
#ifndef BUILD_GITHUB_PLUGIN
    m_rbFpLibFormat->Enable( GITHUB_PLUGIN, false );

    if( m_rbFpLibFormat->GetSelection() == GITHUB_PLUGIN )
        m_rbFpLibFormat->SetSelection( KICAD_PLUGIN );
#endif

    // Currently, I (JPC) do not know the best way to add/store
    // what is currently called env variables
    // So do not show tools to change them,
    // but do not remove the code, just in case
	m_buttonAddEV->Show( false );
	m_buttonRemoveEV->Show( false );

#ifndef BUILD_GITHUB_PLUGIN
    m_buttonGithubLibList->Show( false );
#endif

    // Gives a minimal size to the dialog, which allows displaying any page
    wxSize minsize;

    for( unsigned ii = 0; ii < m_pages.size(); ii++ )
    {
        wxSize size = m_pages[ii]->GetSizer()->CalcMin();
        minsize.x = std::max( minsize.x, size.x );
        minsize.y = std::max( minsize.y, size.y );
    }

    SetMinSize( minsize );
    SetPageSize( minsize );
    GetSizer()->SetSizeHints( this );
    Center();
}


WIZARD_FPLIB_TABLE::~WIZARD_FPLIB_TABLE()
{
    // Use this if you want to store kicad lib URL in pcbnew/cvpcb section config:
//    wxConfigBase* cfg = Kiface().KifaceSettings();
    // Use this if you want to store kicad lib URL in common section config:
    wxConfigBase* cfg = Pgm().CommonSettings();
    cfg->Write( KICAD_FPLIBS_URL_KEY, m_textCtrlGithubURL->GetValue() );

    m_last_plugin_choice = m_rbFpLibFormat->GetSelection();
    m_last_defaultpath_choice = m_rbPathManagement->GetSelection();

    cfg->Write( WIZARD_LAST_PLUGIN_KEY, m_last_plugin_choice );
    cfg->Write( WIZARD_LAST_PATHOPTION_KEY, m_last_defaultpath_choice );
}


void WIZARD_FPLIB_TABLE::initDlg( wxArrayString& aEnvVariableList )
{
    m_currLibDescr = NULL;

    SetBitmap( KiBitmap( wizard_add_fplib_icon_xpm ) );

    wxString msg;
    wxConfigBase* cfg = Pgm().CommonSettings();
    cfg->Read( WIZARD_LAST_PLUGIN_KEY, &m_last_plugin_choice );
    cfg->Read( WIZARD_LAST_PATHOPTION_KEY, &m_last_defaultpath_choice );
    cfg->Read( KICAD_FPLIBS_URL_KEY, &msg );

    if( msg.IsEmpty() )     // Give our current KiCad github URL
        msg = wxT( "http://github.com/KiCad" );

    // Be sure there is no trailing '/' at the end of the repo name
    if( msg.EndsWith( wxT("/" ) ) )
        msg.RemoveLast();

    m_textCtrlGithubURL->SetValue( msg );

    // KIGITHUB is frequently used (examples in docs, and other place)
    // So add it if it not yet in list, but if it is defined as env var
    // (note this env var is not hardcoded or existing in kicad sources)
    if( aEnvVariableList.Index( wxT("KIGITHUB"), false ) == wxNOT_FOUND )
    {
        //  Not yet in use in lib table, see in env. vars
        wxString evValue;
        wxGetEnv( wxT("KIGITHUB"), &evValue );

        //  Not yet in use in lib table, but it is defined in environment,
        // so add it, just in case
        if( ! evValue.IsEmpty() )
            aEnvVariableList.Add( wxT("KIGITHUB") );
    }

    m_rowPrjEnvVarPosition = 0;
    m_predefinedEnvVarCnt = aEnvVariableList.GetCount();

    for( int row = 0; row < m_predefinedEnvVarCnt; row++ )
    {
        if( GetEnvVarCount() <= row )
            m_gridEnvironmentVariablesList->AppendRows(1);

        m_gridEnvironmentVariablesList->SetCellValue( row, 0, aEnvVariableList[row] );

        if( aEnvVariableList[row] == PROJECT_VAR_NAME )
            m_rowPrjEnvVarPosition = row;

        wxString evValue;

        if( wxGetEnv( aEnvVariableList[row], &evValue ) )
            m_gridEnvironmentVariablesList->SetCellValue( row, 1, evValue );

        // All these env var are defined outside the wizard,
        // and cannot be modified in this dialog
        m_gridEnvironmentVariablesList->SetReadOnly( row, 0, true );
        m_gridEnvironmentVariablesList->SetReadOnly( row, 1, true );
    }

    m_gridEnvironmentVariablesList->Fit();

    m_buttonRemoveEV->Enable( GetEnvVarCount() > m_predefinedEnvVarCnt );
    m_gridEnvironmentVariablesList->AutoSizeColumns();

    m_rbFpLibFormat->SetSelection( m_last_plugin_choice );
    m_rbPathManagement->SetSelection( m_last_defaultpath_choice );

    wxCommandEvent event;
    updateFromPlugingChoice();
    OnPathManagementSelection( event );
}

int WIZARD_FPLIB_TABLE::HasGithubEnvVarCompatible()
{
    // Return true if at least one env var defines a url relative to github
    for( int row = 0; row < GetEnvVarCount(); row++ )
    {
        if( m_gridEnvironmentVariablesList->GetCellValue(
                wxGridCellCoords( row, 1 ) ).Lower().StartsWith( "http" ) )
            return row;
    }

    return -1;
}


bool WIZARD_FPLIB_TABLE::ValidateOptions()
{
    // Some choices can be conficting or do not work.
    // Warn the user when this is the case
    wxString msg;

    if( getSelectedEnvVarValue().IsEmpty() )
    {
        // PROJECT_PATH option cannot be used with empty local path
        if( m_rbPathManagement->GetSelection() == PROJECT_PATH )
        {
            msg = _("The project path is empty and this option is not valid.\n"
                    "Looks like you are running the wizard outside a project.");
            wxMessageBox( msg );
            return false;
        }
        else if( m_rbPathManagement->GetSelection() != ABSOLUTE_PATH )
        {
            wxMessageBox( wxString::Format(
                _("The default path defined by env var \"%s\" is empty.\nCannot use it"),
                GetChars( getSelectedEnvVar() ) ) );
            return false;
        }
    }
    else
    {
        if( IsGithubPlugin() )
        {
            // Github plugin cannot be used with local path; Need absolute path or valid URL
            if( !getSelectedEnvVarValue().Lower().StartsWith( "http" ) )
            {
                msg = _("Github Plugin uses a valid Internet URL starting by http.\n"
                        "Cannot be used as URL");
                wxMessageBox( msg );
                return false;
            }
        }
        else
        {
            if( getSelectedEnvVarValue().Lower().StartsWith( "http" ) )
            {
                msg = _("This default path looks strange.\n"
                        "Cannot be used for a file path");
                wxMessageBox( msg );
                return false;
            }
        }
    }

    // Other conficts: TODO

    return true;
}


void WIZARD_FPLIB_TABLE::OnPluginSelection( wxCommandEvent& event )
{
    updateFromPlugingChoice();
}

void WIZARD_FPLIB_TABLE::updateFromPlugingChoice()
{
    #ifdef BUILD_GITHUB_PLUGIN
    m_buttonGithubLibList->Show( IsGithubPlugin() || IsKicadPlugin() );
    #endif

    // update dialog options and widgets depending on a plugin choice
    // Project path has no sense for GITHUB_PLUGIN
    bool enablePrjPathOpt = not IsGithubPlugin();

    // Project path cannot be used if unknown
    if( m_gridEnvironmentVariablesList->GetCellValue(
                                wxGridCellCoords( m_rowPrjEnvVarPosition, 1 ) ).IsEmpty() )
        enablePrjPathOpt = false;

    m_rbPathManagement->Enable( PROJECT_PATH, enablePrjPathOpt );

    // Sometimes only the choice "absolute path" is allowed;
    // Force this choice, at least make it the default choice
    bool force_absolute_path = false;

    // For github plugin, the project path is not allowed
    if( ( m_rbPathManagement->GetSelection() == PROJECT_PATH ) && !enablePrjPathOpt )
        force_absolute_path = true;

    // For github plugin, at least one github compatible path must exist
    // If no github path, force absolute path
    int first_github_envvar = HasGithubEnvVarCompatible();
    if( IsGithubPlugin() )
    {
        if( first_github_envvar < 0 )
            force_absolute_path = true;
        else if( !getSelectedEnvVarValue().StartsWith( "http" ) )
                m_gridEnvironmentVariablesList->SelectRow( first_github_envvar );

    }

    if( force_absolute_path )
        m_rbPathManagement->SetSelection( ABSOLUTE_PATH );
}


void WIZARD_FPLIB_TABLE::OnPathManagementSelection( wxCommandEvent& event )
{
    // Disable irrevant options, and enable others.
    int row_count = GetEnvVarCount();

    switch( m_rbPathManagement->GetSelection() )
    {
        case PROJECT_PATH:          // Choice = path relative to the project
            m_gridEnvironmentVariablesList->Enable( true );
            m_buttonAddEV->Enable( false );
            m_gridEnvironmentVariablesList->ShowRow( PROJECT_PATH );

            for( int row = 0; row < row_count; row++ )
            {
                if( row == PROJECT_PATH )
                    continue;

                m_gridEnvironmentVariablesList->HideRow( row );
            }
            break;

        case ENV_VAR_PATH:          // Choice = path relative to env var
            m_gridEnvironmentVariablesList->Enable( true );
            m_buttonAddEV->Enable( true );

            for( int row = 0; row < row_count; row++ )
                m_gridEnvironmentVariablesList->ShowRow( row );

            break;

        case ABSOLUTE_PATH:          // Choice = path relative to the project
            m_gridEnvironmentVariablesList->Enable( false );
            m_buttonAddEV->Enable( false );
            break;
    }
}

void WIZARD_FPLIB_TABLE::OnAddEVariable( wxCommandEvent& event )
{
    m_gridEnvironmentVariablesList->AppendRows( 1 );
    m_gridEnvironmentVariablesList->AutoSizeColumns();
    m_buttonRemoveEV->Enable( GetEnvVarCount() > m_predefinedEnvVarCnt );
    m_gridEnvironmentVariablesList->SetGridCursor( GetEnvVarCount()-1, 0 );
}

void WIZARD_FPLIB_TABLE::OnRemoveEVariable( wxCommandEvent& event )
{
    wxArrayInt selectedRows	= m_gridEnvironmentVariablesList->GetSelectedRows();
    int row_cursor = m_gridEnvironmentVariablesList->GetGridCursorRow();

    if( selectedRows.size() == 0 && row_cursor >= 0 )
        selectedRows.Add( row_cursor );

    std::sort( selectedRows.begin(), selectedRows.end() );

    for( int ii = selectedRows.GetCount()-1; ii >= 0; ii-- )
    {
        int row = selectedRows[ii];

        // don't remove them env var. which are already existing in lib table
        if( row > m_predefinedEnvVarCnt-1 )
            m_gridEnvironmentVariablesList->DeleteRows( row, 1 );
    }

    m_gridEnvironmentVariablesList->SelectRow( m_gridEnvironmentVariablesList->GetGridCursorRow() );
    m_buttonRemoveEV->Enable( GetEnvVarCount() > m_predefinedEnvVarCnt );
}

void WIZARD_FPLIB_TABLE::OnSelectEnvVarCell( wxGridEvent& event )
{
    // Ensure the selected row is also the row which have the focus.
    // useful when the user want to delete a row, and select it by the mouse
    m_gridEnvironmentVariablesList->SelectRow( event.GetRow() );
}

wxString WIZARD_FPLIB_TABLE::getSelectedEnvVar()
{
    wxString envVar;
    wxArrayInt selectedRows	= m_gridEnvironmentVariablesList->GetSelectedRows();
    int row   = selectedRows.GetCount() ? selectedRows[0] :
                m_gridEnvironmentVariablesList->GetGridCursorRow();

    switch( m_rbPathManagement->GetSelection() )
    {
        case ENV_VAR_PATH:    // Choice = path relative to env var
            envVar = m_gridEnvironmentVariablesList->GetCellValue(
                                wxGridCellCoords( row, 0 ) );
            break;

        case PROJECT_PATH:    // Choice = path relative to the project
            envVar = PROJECT_VAR_NAME;
            break;

        case ABSOLUTE_PATH:    // Choice = absolute path
        default:
            break;
    }

    return envVar;
}


wxString WIZARD_FPLIB_TABLE::getSelectedEnvVarValue()
{
    wxString envVarValue;
    wxArrayInt selectedRows	= m_gridEnvironmentVariablesList->GetSelectedRows();
    int row   = selectedRows.GetCount() ? selectedRows[0] :
                m_gridEnvironmentVariablesList->GetGridCursorRow();

    switch( m_rbPathManagement->GetSelection() )
    {
        case ENV_VAR_PATH:    // Choice = path relative tp env var
            envVarValue = m_gridEnvironmentVariablesList->GetCellValue(
                                wxGridCellCoords( row, 1 ) );
            break;

        case PROJECT_PATH:    // Choice = path relative to the project
            envVarValue = m_gridEnvironmentVariablesList->GetCellValue(
                                wxGridCellCoords( m_rowPrjEnvVarPosition, 1 ) );
            break;

        case ABSOLUTE_PATH:    // Choice = absolute path
        default:
            break;
    }

    return envVarValue;
}

void WIZARD_FPLIB_TABLE::OnPageChanged( wxWizardEvent& event )
{
    if( GetCurrentPage() == m_pages[2] )
        setLastPage();
    else if( GetCurrentPage() == m_pages[1] )
        setSecondPage();
}

void WIZARD_FPLIB_TABLE::OnPageChanging( wxWizardEvent& event )
{
    if( !( GetCurrentPage() == m_pages[1] && event.GetDirection() ) )
        return;

    if( ! ValidateOptions() )
    {
        event.Veto();
        return;
    }

    if( ( m_rbPathManagement->GetSelection() != ABSOLUTE_PATH ) &&
        ( IsGithubPlugin() ) )
    {
        wxURI uri( getSelectedEnvVarValue() );

        // We cannot use wxURL to test the validity of the url, because
        // wxURL does not know https protocol we are using, and aways returns
        // error for url starting by https
        bool badurl = !uri.HasPath();

        if( badurl )
        {
            wxMessageBox( wxString::Format(
                _("The URL defined by env var \"%s\" is an incorrect URL.\nCannot use it"),
                GetChars( getSelectedEnvVar() ) ) );
            event.Veto();
        }
    }
}

bool WIZARD_FPLIB_TABLE::setSecondPage()
{
    // Init parameters for the second wizard page: this is only
    // the current library description.
    updateFromPlugingChoice();

    delete m_currLibDescr;
    m_currLibDescr = NULL;

    switch( m_rbFpLibFormat->GetSelection() )
    {
        case 0:     // Kicad lib type
            m_currLibDescr = new LIB_DESCR_KICAD;
            m_buttonGithubLibList->SetLabel( _("Download Github Libs") );
            break;

        case 1:     // Github lib type
            m_currLibDescr = new LIB_DESCR_GITHUB;
            m_buttonGithubLibList->SetLabel( _("Github Libs List") );
            break;

        case 2:     // Legacy lib type
            m_currLibDescr = new LIB_DESCR_LEGACY;
            break;

        case 3:     // Eagle V6 lib type
            m_currLibDescr = new LIB_DESCR_EAGLE;
            break;

        case 4:     // Geda lib type
            m_currLibDescr = new LIB_DESCR_GEDA;
            break;
    }

    if( IsGithubPlugin() )
    {
#ifdef KICAD_USE_WEBKIT
        m_buttonAddLib->SetLabel( _("Add Libs with WebViewer") );
#else
        m_buttonAddLib->SetLabel( _("Add FP Library entry") );
#endif
    }
    else
        m_buttonAddLib->SetLabel( _("Add FP Libraries") );

    return m_currLibDescr!= NULL;
}

bool WIZARD_FPLIB_TABLE::setLastPage()     // Init prms for the last wizard page
{
    // Update texts in last wizard page
    m_textPluginType->SetLabel( m_rbFpLibFormat->GetStringSelection() );

    switch( m_rbPathManagement->GetSelection() )
    {
        case ENV_VAR_PATH:    // Choice = path relative env var
        case PROJECT_PATH:    // Choice = path relative to the project
            m_currLibDescr->m_EnvVarName = getSelectedEnvVar();
            m_currLibDescr->m_DefaultPath = getSelectedEnvVarValue();
            m_currLibDescr->m_IsAbsolutePath = false;

            m_textOption->SetLabel( wxString::Format( wxT("%s (%s)"),
                m_rbPathManagement->GetStringSelection().GetData(),
                getSelectedEnvVar().GetData() ) );

            m_textPath->SetLabel( getSelectedEnvVarValue() );
            break;

        case ABSOLUTE_PATH:    // Choice = absolute path
            m_currLibDescr->m_IsAbsolutePath = true;

            m_textOption->SetLabel( m_rbPathManagement->GetStringSelection() );

            if( IsGithubPlugin() )
                m_textPath->SetLabel( _("Full URL") );
            else
                m_textPath->SetLabel( _("Full filename") );
            break;
    }

    return true;
}



void WIZARD_FPLIB_TABLE::OnAddFpLibs( wxCommandEvent& event )
{
    if( m_currLibDescr->m_IsFile )
        selectLibsFiles();
    else if( m_currLibDescr->m_IsGitHub )
        selectLibsGithubWithWebViewer();
    else
        selectLibsFolders();

    m_gridFpListLibs->SetGridCursor( GetLibsCount()-1, 0 );
    m_gridFpListLibs->SelectRow( GetLibsCount()-1 );
}

void WIZARD_FPLIB_TABLE::selectLibsFiles()     // select a set of library files
{
    wxString msk = wxT("*.") + m_currLibDescr->m_Ext;

    wxFileDialog dlg( this, _("Select Library Files"), m_currLibDescr->m_DefaultPath,
                      wxEmptyString, msk,
                      wxFD_DEFAULT_STYLE|wxFD_FILE_MUST_EXIST|wxFD_MULTIPLE );

    dlg.ShowModal();

    wxArrayString filepaths;
    dlg.GetPaths( filepaths );

    // Create the nickname: currently make it from the filename
    wxArrayString nicknames;
    wxFileName fn;

    for( unsigned ii = 0; ii < filepaths.GetCount(); ii++ )
    {
        fn = filepaths[ii];
        nicknames.Add( fn.GetName() );

        if( m_currLibDescr->m_IsAbsolutePath || m_currLibDescr->m_DefaultPath.IsEmpty() )
        {
            filepaths[ii] = fn.GetPathWithSep();
        }
        else
        {
            if( ! fn.MakeRelativeTo( m_currLibDescr->m_DefaultPath ) )
                filepaths[ii] = fn.GetFullPath();
            else
                filepaths[ii].Printf( wxT("${%s}%c%s"),
                    GetChars( m_currLibDescr->m_EnvVarName ),
                    fn.GetPathSeparator(),
                    GetChars( fn.GetFullPath() ) );
        }
#ifdef __WINDOWS__
        // We store paths using Unix notation, which also works fine on Windows
        filepaths[ii].Replace( wxT("\\"), wxT("/") );
#endif
    }

    populateLibList( nicknames, filepaths, m_currLibDescr->m_PluginName );
    m_gridFpListLibs->AutoSizeColumns();
}


void WIZARD_FPLIB_TABLE::populateLibList( const wxArrayString& aNickNames,
                                          const wxArrayString& aPaths,
                                          const wxString& aPluginName )
{
    if( aPaths.GetCount() <= 0 )
        return;

    // Ensure there is room for selected libs
    int first_row = m_gridFpListLibs->GetTable()->GetRowsCount();
    m_gridFpListLibs->AppendRows( aPaths.GetCount() );

    // Populates the library list
    for( unsigned ii = 0; ii < aPaths.GetCount(); ii++ )
    {
        int jj = first_row + ii;
        // Add the nickname: currently make it from filename
        m_gridFpListLibs->SetCellValue( jj, 0, aNickNames[ii] );
        // Add the full path:
        m_gridFpListLibs->SetCellValue( jj, 1, aPaths[ii] );
        // Add the plugin name:
        m_gridFpListLibs->SetCellValue( jj, 2, aPluginName );
        m_gridFpListLibs->SetReadOnly( jj, 2, true );
    }

    m_gridFpListLibs->Fit();
}


// A helper dialog to show and select a set of directories
class DIALOG_SELECT_DIRLIST : public DIALOG_SELECT_DIRLIST_BASE
{
public:
    DIALOG_SELECT_DIRLIST( wxWindow* parent,
                              const wxString& aDefaultPath ):
                DIALOG_SELECT_DIRLIST_BASE( parent, wxID_ANY )
    {
        if( !aDefaultPath.IsEmpty() )
            m_dirCtrl->SetPath( aDefaultPath );

        Layout();
        GetSizer()->Fit( this );
        GetSizer()->SetSizeHints(this);
        Centre();
    }

    ~DIALOG_SELECT_DIRLIST() {};

    void GetPaths( wxArrayString& aPaths ) { m_dirCtrl->GetPaths( aPaths ); }
};

void WIZARD_FPLIB_TABLE::selectLibsFolders()   // select a set of library folders
{
    DIALOG_SELECT_DIRLIST dlg( this, m_currLibDescr->m_DefaultPath );

    if( dlg.ShowModal() != wxID_OK )
        return;

    wxArrayString filepaths;

    dlg.GetPaths( filepaths );

    // Create the nickname: currently make it from the filename
    wxArrayString nicknames;
    wxFileName fn;

    for( unsigned ii = 0; ii < filepaths.GetCount(); ii++ )
    {
        fn = filepaths[ii];
        nicknames.Add( fn.GetName() );

        fn.AssignDir( filepaths[ii] );

        if( m_currLibDescr->m_IsAbsolutePath || m_currLibDescr->m_DefaultPath.IsEmpty() )
        {
            filepaths[ii] = fn.GetFullPath();
        }
        else
        {
            if( ! fn.MakeRelativeTo( m_currLibDescr->m_DefaultPath ) )
                filepaths[ii] = fn.GetFullPath();
            else
                filepaths[ii].Printf( wxT("${%s}%c%s"),
                    GetChars( m_currLibDescr->m_EnvVarName ),
                    fn.GetPathSeparator(),
                    GetChars( fn.GetFullPath() ) );
        }
#ifdef __WINDOWS__
        // We store paths using Unix notation, which also works fine on Windows
        filepaths[ii].Replace( wxT("\\"), wxT("/") );
#endif
        // Remove trailing path separator, if any.
        if( filepaths[ii].EndsWith( wxT("/") ) )
            filepaths[ii].RemoveLast();
    }

    populateLibList( nicknames, filepaths, m_currLibDescr->m_PluginName );
}

#ifdef KICAD_USE_WEBKIT

// A helper function to run the wen viewer (see webviewer.cpp)
extern int RunWebViewer( wxWindow * aParent, const wxString& aUrlOnStart,
                         wxArrayString* aUrlListSelection = NULL );
#endif

void WIZARD_FPLIB_TABLE::selectLibsGithubWithWebViewer()    // select a set of library on Github
{
    // A string array to store the URLs selected from the web viewer:
    wxArrayString urls;

    // Run the web viewer and open the default URL: the default path
    // or our github library repos
    wxString defaultURL = m_currLibDescr->m_DefaultPath;

    if( defaultURL.IsEmpty() )
        defaultURL = wxT( "https://github.com/KiCad" );
#ifdef KICAD_USE_WEBKIT
    RunWebViewer( this, defaultURL, &urls );
#else
    // If the Web Viewer is not available, just add a template
    // to the fp lib table.
    // The user have to edit it
    urls.Add( defaultURL + wxT("/newlibname.pretty") );
#endif
    installGithubLibsFromList( urls );
}

void WIZARD_FPLIB_TABLE::installGithubLibsFromList( wxArrayString& aUrlList )
{
    // add the libs found in aUrlList, after calculating a nickname and
    // replacing the path by an env variable, if needed
    // Create the nickname: currently make it from the url
    wxArrayString filepaths;
    wxArrayString nicknames;

    for( unsigned ii = 0; ii < aUrlList.GetCount(); ii++ )
    {
        wxString urlstring( aUrlList[ii] );

        wxURI uri( urlstring );

        // We cannot use wxURL to test the validity of the url, because
        // wxURL does not know https protocol we are using, and aways returns
        // error for URLs starting by https. Hope this test is enough
        if( uri.HasPath() )
            nicknames.Add( uri.GetPath().AfterLast( '/').BeforeLast( '.' ) );
        else
            continue;   // Should not happen: bad URL

        if( m_currLibDescr->m_IsAbsolutePath ||
            m_currLibDescr->m_DefaultPath.IsEmpty() )
        {
            filepaths.Add( aUrlList[ii] );  // use the full URL
        }
        else
        {
            wxString shortURI;
            if( aUrlList[ii].Lower().StartsWith(
                        m_currLibDescr->m_DefaultPath.Lower(), &shortURI ) )
            {
                shortURI.Prepend( wxT("${") + m_currLibDescr->m_EnvVarName + wxT("}") );
                filepaths.Add( shortURI );
            }
            else    //  keep the full URL
                filepaths.Add( aUrlList[ii] );   // use the full URL
        }
    }

    populateLibList( nicknames, filepaths, m_currLibDescr->m_PluginName );
}


void WIZARD_FPLIB_TABLE::OnRemoveFpLibs( wxCommandEvent& event )
{
    wxArrayInt selectedRows	= m_gridFpListLibs->GetSelectedRows();
    int row_cursor = m_gridFpListLibs->GetGridCursorRow();

    if( selectedRows.size() == 0 && row_cursor >= 0 )
        selectedRows.Add( row_cursor );

    std::sort( selectedRows.begin(), selectedRows.end() );

    for( int ii = selectedRows.GetCount()-1; ii >= 0; ii-- )
    {
        int row = selectedRows[ii];
        m_gridFpListLibs->DeleteRows( row, 1 );
    }

    m_gridFpListLibs->SelectRow( m_gridFpListLibs->GetGridCursorRow() );
}

#ifdef BUILD_GITHUB_PLUGIN
#include <../github/github_getliblist.h>

void WIZARD_FPLIB_TABLE::OnGithubLibsList( wxCommandEvent& event )
{
    wxArrayString liblist;
    getLibsListGithub( liblist );

    if( liblist.GetCount() == 0 )   // No lib selected
        return;

    if( IsKicadPlugin() )
    {
        wxString msg;

        if( !downloadGithubLibsFromList( liblist, &msg ) )
        {
            wxMessageBox( msg );
            return;
        }
    }
    else
        installGithubLibsFromList( liblist );
}

void WIZARD_FPLIB_TABLE::getLibsListGithub( wxArrayString& aList )
{
    wxBeginBusyCursor();

    // Be sure there is no trailing '/' at the end of the repo name
    wxString git_url = m_textCtrlGithubURL->GetValue();
    if( git_url.EndsWith( wxT("/" ) ) )
    {
        git_url.RemoveLast();
        m_textCtrlGithubURL->SetValue( git_url );
    }

    GITHUB_GETLIBLIST getter( git_url );

    wxArrayString fullList;
    getter.GetLibraryList( fullList );

    wxEndBusyCursor();

    wxArrayInt choices;
    wxString msg( _( "Urls detected as footprint .pretty libraries.\n"
                     "Selected urls will be added to the current footprint library list" ) );

    if( wxGetSelectedChoices( choices, msg,
                _( "Footprint libraries" ), fullList, this ) <= 0 )
        return;

    // Add selected url in list
    for( unsigned ii = 0; ii < choices.GetCount(); ii++ )
    {
        wxString& url = fullList[choices[ii]];
        aList.Add( url );
    }
}


// Download the .pretty libraries found in aUrlLis and store them on disk
// in a master folder
bool WIZARD_FPLIB_TABLE::downloadGithubLibsFromList( wxArrayString& aUrlList,
                                                     wxString * aErrorMessage )
{
    wxString masterFolder;
    wxString default_path;
    wxGetEnv(  FP_LIB_TABLE::GlobalPathEnvVariableName(), &default_path );

    masterFolder =	wxDirSelector( _("Output Folder" ),
                                   default_path, 0, wxDefaultPosition, this );

    if( masterFolder.IsEmpty() )    // Aborted by user
    {
        if( aErrorMessage )
            *aErrorMessage = _( "Aborted" );

        return false;
    }

    if( !wxDirExists( masterFolder ) )
    {
        if( aErrorMessage )
            aErrorMessage->Printf( _( "Folder '%s' does not exists" ),
                                   GetChars( masterFolder ) );

        return false;
    }

    // Display a progress bar to show the downlaod state
    wxProgressDialog pdlg( _("Download libraries"), wxEmptyString, aUrlList.GetCount() );

    // Download libs:
    for( unsigned ii = 0; ii < aUrlList.GetCount(); ii++ )
    {
        wxString& libsrc_name = aUrlList[ii];
        wxString libdst_name;

        // Extract the lib name from the full URL:
        wxURI url( libsrc_name );
        wxFileName fn( url.GetPath() );
        // Set our local path
        fn.SetPath( masterFolder );
        libdst_name = fn.GetFullPath();

        if( !wxDirExists( libdst_name ) )
            wxMkdir( libdst_name );

        pdlg.Update( ii, libsrc_name);

        try
        {
            PLUGIN::RELEASER src( IO_MGR::PluginFind( IO_MGR::GITHUB ) );
            PLUGIN::RELEASER dst( IO_MGR::PluginFind( IO_MGR::KICAD ) );

            wxArrayString footprints = src->FootprintEnumerate( libsrc_name );

            for( unsigned i = 0;  i < footprints.size();  ++i )
            {
                std::auto_ptr<MODULE> m( src->FootprintLoad( libsrc_name, footprints[i] ) );
                dst->FootprintSave( libdst_name, m.get() );
                // m is deleted here by auto_ptr.
            }
        }
        catch( const IO_ERROR& ioe )
        {
            if( aErrorMessage )
                aErrorMessage->Printf( _("Error:\n'%s'\nwhile downloading library:\n'%s'"),
                                       GetChars( ioe.errorText ), GetChars( libsrc_name ) );
            return false;
        }
    }

    return true;
}
#endif