//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// copyright            : (C) 2009 by Eran Ifrah
// file name            : refactorengine.h
//
// -------------------------------------------------------------------------
// A
//              _____           _      _     _ _
//             /  __ \         | |    | |   (_) |
//             | /  \/ ___   __| | ___| |    _| |_ ___
//             | |    / _ \ / _  |/ _ \ |   | | __/ _ )
//             | \__/\ (_) | (_| |  __/ |___| | ||  __/
//              \____/\___/ \__,_|\___\_____/_|\__\___|
//
//                                                  F i l e
//
//    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.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef REFACTORENGINE_H
#define REFACTORENGINE_H

#include <wx/event.h>
#include <wx/filename.h>
#include <vector>
#include <list>
#include "entry.h"
#include "cppwordscanner.h"
#include "cpptoken.h"
#include "codelite_exports.h"
#include "refactoring_storage.h"

class clProgressDlg;

//----------------------------------------------------------------------------------

struct RefactorSource {
    wxString name;
    wxString scope;
    bool     isClass;

    RefactorSource() : name(wxEmptyString), scope(wxEmptyString), isClass(false) {
    }

    void Reset() {
        name.clear();
        scope.clear();
        isClass = false;
    }
};

//-----------------------------------------------------------------------------------
extern WXDLLIMPEXP_CL const wxEventType wxEVT_REFACTORING_ENGINE_CACHE_INITIALIZING;

class WXDLLIMPEXP_CL RefactoringEngine
{
    std::list<CppToken> m_candidates;
    std::list<CppToken> m_possibleCandidates;
    wxEvtHandler *      m_evtHandler;
    RefactoringStorage  m_storage;
    
public:
    static RefactoringEngine* Instance();
    
protected:
    clProgressDlg *CreateProgressDialog(const wxString &title, int maxValue);
    void DoFindReferences(const wxString &symname, const wxFileName& fn, int line, int pos, const wxFileList_t& files, bool onlyDefiniteMatches);

private:
    RefactoringEngine();
    ~RefactoringEngine();
    bool DoResolveWord(  TextStatesPtr states,
                         const wxFileName& fn,
                         int pos,
                         int line,
                         const wxString &word,
                         RefactorSource *rs);

public:
    void InitializeCache(const wxFileList_t& files) {
        m_storage.InitializeCache(files);
    }
    bool IsCacheInitialized() const;
    void SetCandidates(const std::list<CppToken>& candidates) {
        this->m_candidates = candidates;
    }
    void SetPossibleCandidates(const std::list<CppToken>& possibleCandidates) {
        this->m_possibleCandidates = possibleCandidates;
    }
    const std::list<CppToken>& GetCandidates() const {
        return m_candidates;
    }
    const std::list<CppToken>& GetPossibleCandidates() const {
        return m_possibleCandidates;
    }
    wxString GetExpression(int pos, TextStatesPtr states);

    void Clear();
    /**
     * @brief rename global symbol. Global Symbol can be one of:
     * <li>member
     * <li>global variable
     * <li>class
     * <li>struct
     * <li>union
     * <li>namespace
     * <li>function
     * <li>prototype
     * <li>typedef
     * @param symname the name of the symbol
     * @param fn current file
     * @param line the symbol is loacted in this file
     * @param pos at that position
     * @param files perform the refactoring on these files
     */
    void RenameGlobalSymbol(const wxString &symname, const wxFileName& fn, int line, int pos, const wxFileList_t& files);

    /**
     * @param rename local variable
     * @param symname symbol we want to rename
     * @param fn the current file name (full path)
     * @param line the line where our symbol appears
     * @param pos the position of the symbol (this should be pointing to the *start* of the symbol)
     */
    void RenameLocalSymbol (const wxString &symname, const wxFileName& fn, int line, int pos);

    /**
     * @brief find usages of given symbol in a list of files
     * @param symname symbol to search for
     * @param fn active file open which holds the context of the symbol
     * @param line the line where the symbol exists
     * @param pos the position of the symbol (this should be pointing to the *start* of the symbol)
     * @param files list of files to search in
     */
    void FindReferences(const wxString &symname, const wxFileName& fn, int line, int pos, const wxFileList_t& files);

    /**
     * @brief given a location (file:line:pos) use the current location function signature
     * and return the propsed counter-part tag
     */
    TagEntryPtr SyncSignature(const wxFileName& fn, int line, int pos, const wxString &word, const wxString &text, const wxString &expr);
};

#endif // REFACTORENGINE_H