#pragma once

enum varType { SCALAR, ARRAY, CONST, ANOTHER };

struct CommonVariableUse
{
private:
    std::string fileName;
    std::string functionName;
    SgSymbol *useS;

    SgFile *file;
    SgStatement *function;
    bool isBlockData;
public:
    explicit CommonVariableUse(SgFile *file, SgStatement *function, SgSymbol *useS) :
        file(file), function(function), useS(useS),
        fileName(std::string(file->filename())), functionName(std::string(function->symbol()->identifier()))
    {
        if (function->variant() == BLOCK_DATA)
            isBlockData = true;
        else
            isBlockData = false;
    }

    const std::string& getFileName() const { return fileName; }
    const std::string& getFunctionName() const { return functionName; }
    bool isBlockDataUse() const { return isBlockData; }
    SgFile* getFile() const { return file; }
    SgStatement* getFunction() const { return function; }
    SgSymbol* getUseS() const { return useS; }
    SgStatement* getDeclaratedPlace() const 
    {
        if (current_file->filename() != fileName)
            SgFile::switchToFile(fileName);
        return useS->declaredInStmt(); 
    }
};

struct Variable
{
private:
    std::vector<CommonVariableUse> allUse;
    SgSymbol *symbol; // variable symbol
    SgStatement *declPace;

    std::string name; // variable name
    varType type;     // variable type
    int position;
public:
    explicit Variable(SgFile* file, SgStatement* function, SgSymbol* symbol, const std::string& name, const varType type, const int position);

    SgSymbol* getSymbol() const { return symbol; }
    const std::vector<CommonVariableUse>& getAllUse() const { return allUse; }
    const std::string& getName() const { return name; }
    varType getType() const { return type; }
    int getPosition() const { return position; }
    SgStatement *getDeclarated() const { return declPace; }

    void addUse(SgFile *file, SgStatement *function, SgSymbol *useS)
    {
        for (auto &use : allUse)
            if (use.getFile() == file && use.getFunction() == function)
                return;

        allUse.push_back(CommonVariableUse(file, function, useS));
    }

    bool hasUse(const std::string &file, const std::string &function) const
    {
        for (auto &use : allUse)
            if (use.getFileName() == file && use.getFunctionName() == function)
                return true;

        return false;
    }

    void print(FILE *fileOut) const
    {
        fprintf(fileOut, "  %3d, '%s', %s\n", position, name.c_str(), type == SCALAR ? "SCALAR" : type == ARRAY ? "ARRAY" : "ANOTHER");
    }
};

struct CommonBlock
{
private:
    std::string name;
    std::vector<Variable*> variables;

    // position -> variables
    std::map<int, std::vector<Variable*>> groupedVars;

    Variable* hasVariable(const std::string &name, const varType type, const int position);
    Variable* hasVariable(SgSymbol *symbol, const varType type, const int position);

    // copy and assignment not allowed
    CommonBlock(const CommonBlock&) = delete;
    void operator=(const CommonBlock&) = delete;
public:
    explicit CommonBlock(const std::string &name) : name(name) { }

    const std::string& getName() const { return name; }
    const std::vector<Variable*>& getVariables() const { return variables; }
    const std::map<int, std::vector<Variable*>>& getGroupedVars() const { return groupedVars; }

    const std::vector<const Variable*> getVariables(SgFile *file, SgStatement *function) const;
    const std::vector<const Variable*> getVariables(const std::string &file, const std::string &function) const;
    const std::vector<const Variable*> getVariables(int position) const;

    DIST::Array* getFirstSynonym(DIST::Array* array) const;

    void addVariables(SgFile *file, SgStatement *function, const std::vector<std::pair<SgSymbol*, int>> &newVariables);
    void print(FILE *fileOut) const;

    ~CommonBlock()
    {
        for (auto& elem : variables)
            delete elem;
    }
};