#include <cstdio>
#include <cstring>
#include <fstream>
#include <iostream>
#include <cstdlib>
#include <set>
#include <string>
#include <vector>
#include <algorithm>
#include <tuple>

#include "../Utils/SgUtils.h"
#include "../CFGraph/CFGraph.h"
#include "CFGraph/IR.h"
#include "Distribution/Array.h"
#include "dvm.h"
#include "../Utils/errors.h"
#include "../GraphCall/graph_calls.h"
#include "../GraphCall/graph_calls_func.h"

#include "libSage++.h"
#include "projectParameters.h"
#include "domTree.h"

using namespace std;

tuple<FuncInfo*, SAPFOR::Instruction*, SAPFOR::BasicBlock*> stmtToIR(const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& CFGraph, SgStatement* stmt)
{
    SgStatement* cur = stmt;
    while (cur->variant() != PROC_HEDR && cur->variant() != PROG_HEDR && cur->variant() != FUNC_HEDR)
        cur = cur->controlParent();

    string funcName = ((SgProcHedrStmt*)cur)->nameWithContains();

    int stmtID = stmt->id();
    for (const auto& [func, bblocks] : CFGraph)
    {
        if (func->funcName != funcName)
            continue;

        for (auto basicBlock : bblocks)
            for (auto ins : basicBlock->getInstructions())
                if (stmtID == ins->getInstruction()->getOperator()->id())
                    return make_tuple(func, ins->getInstruction(), basicBlock);
    }

    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
    return { NULL, NULL, NULL };
}

template<typename Iterator>
static void processArgument(set<SAPFOR::Argument*>& worklist,
                            SAPFOR::Argument* arg,
                            Iterator instr,
                            Iterator first_instr)
{
    if (arg == NULL)
        return;
    if (arg->getType() == SAPFOR::CFG_ARG_TYPE::REG)
        extract_vars_from_reg(worklist, arg, instr, first_instr);
    else if (arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR && arg->getMemType() == SAPFOR::CFG_MEM_TYPE::LOCAL_)
    {
        std::cout << "worklist add: " << arg->getValue() << std::endl;           //DEBUG PRINT
        worklist.insert(arg);
    }
}

template<typename Iterator>
static void extract_vars_from_reg(set<SAPFOR::Argument*>& worklist,
                                  SAPFOR::Argument* reg,
                                  Iterator instr,
                                  Iterator first_instr)
{
    for (; instr >= first_instr; instr--)
    {
        if ((*instr)->getInstruction()->getResult() == reg)
        {
            processArgument(worklist, (*instr)->getInstruction()->getArg1(), instr, first_instr);
            processArgument(worklist, (*instr)->getInstruction()->getArg2(), instr, first_instr);
            return;
        }
    }
}

static void lookup_for_vars(std::map<SgStatement*, std::string>& where_to_add,
                            set<SAPFOR::Argument*>& worklist,
                            SAPFOR::Instruction* instr,
                            SAPFOR::BasicBlock* bblock,
                            const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR)
{
    std::cout << "Lookup in bblock no." << bblock->getNumber() << std::endl;                //DEBUG PRINT

    auto first_instr = bblock->getInstructions().begin();
    auto cur_instr = std::find_if(first_instr, bblock->getInstructions().end(), [instr](SAPFOR::IR_Block* i) {
        return i->getInstruction() == instr;
    });

    for (; cur_instr >= bblock->getInstructions().begin(); cur_instr--)
    {
        auto instr = (*cur_instr)->getInstruction();
        auto result_arg = instr->getResult();
        auto arg1 = instr->getArg1();
        auto arg2 = instr->getArg2();

        if (worklist.count(result_arg))
        {
            processArgument(worklist, arg1, cur_instr, first_instr);
            processArgument(worklist, arg2, cur_instr, first_instr);
            std::cout << "worklist erase: " << result_arg->getValue() << std::endl;                 //DEBUG PRINT
            worklist.erase(result_arg);
        }
        if (instr->getOperation() == SAPFOR::CFG_OP::PARAM && worklist.count(arg1))
        {
            // skip to F_CALL
            auto f_call_instr = cur_instr;
            while ((*f_call_instr)->getInstruction()->getOperation() != SAPFOR::CFG_OP::F_CALL)
                f_call_instr++;

            if ((*f_call_instr)->getInstruction()->getArg1()->getValue() == "_READ")
            {
                auto stmt_before = (*f_call_instr)->getInstruction()->getOperator();
                auto filename = stmt_before->fileName();
                auto line = stmt_before->lineNumber();
                auto var_name = arg1->getValue().substr(arg1->getValue().find('%') + 1);
                __spf_print(1,"Please specify value of variable %s on line %d of file %s", arg1->getValue().c_str(), line, filename);
                where_to_add[stmt_before] = var_name;
                std::cout << "worklist erase: " << arg1->getValue() << std::endl;               //DEBUG PRINT
                worklist.erase(arg1);
            } else
            {
                 //check if variable is modified in called function
            }
        }
    }

    const auto& RD = bblock->getRD_In();
    map<SAPFOR::BasicBlock*, SAPFOR::Instruction*> group_by_block;
    for (auto& arg : worklist)
    {
        if (RD.count(arg))
        {
            if (RD.at(arg).size() == 1 && *RD.at(arg).begin() == SAPFOR::CFG_VAL::UNINIT)
                __spf_print(1, "variable %s has no definition", arg->getValue().c_str());
            else if (RD.at(arg).size() > 1)
                __spf_print(1, "variable %s has multiple reaching definitions, further analysis is impossible", arg->getValue().c_str());
            else
            {
                for (const auto& instr_num : RD.at(arg))
                {
                    auto [instr, bblock] = getInstructionAndBlockByNumber(fullIR, instr_num);
                    if (group_by_block[bblock] == NULL || group_by_block[bblock]->getNumber() < instr_num)
                        group_by_block[bblock] = instr;
                }
            }
        }
    }

    auto idom = bblock->getIdom();
    while (idom != NULL)
    {
        if (group_by_block.count(idom))
        {
            lookup_for_vars(where_to_add, worklist, group_by_block[idom], idom, fullIR);
            return;
        }
        idom = idom->getIdom();
    }
}

static void handle_single_allocate(std::map<SgStatement*, std::string>& where_to_add,
                                   SgStatement* alloc_statement,
                                   const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR)
{
    auto [func, instr, bblock] = stmtToIR(fullIR, alloc_statement);

    auto first_instr = bblock->getInstructions().begin();
    auto cur_instr = std::find_if(first_instr, bblock->getInstructions().end(), [instr](SAPFOR::IR_Block* i) {
        return i->getInstruction() == instr;
    });
    auto alloc_instr = cur_instr;

    // skip to F_CALL _ALLOC n
    while ((*alloc_instr)->getInstruction()->getOperation() != SAPFOR::CFG_OP::F_CALL ||
           (*alloc_instr)->getInstruction()->getArg1()->getValue() != "_ALLOC")
    {
        alloc_instr++;
    }

    auto arrays_num = stoi((*alloc_instr)->getInstruction()->getArg2()->getValue());
    std::cout << "arrays_num: " << arrays_num << std::endl;                 //DEBUG PRINT

    set<SAPFOR::Argument*> worklist;
    for (int i = 0; i < arrays_num; i++)
    {
        auto param_instr = --alloc_instr;
        auto param_reg = (*param_instr)->getInstruction()->getArg1();

        while ((*param_instr)->getInstruction()->getOperation() != SAPFOR::CFG_OP::LOAD ||
               (*param_instr)->getInstruction()->getResult() != param_reg)
        {
            param_instr--;
        }

        auto dimensions_num = stoi((*param_instr)->getInstruction()->getArg2()->getValue());

        for (int j = 0; j < dimensions_num; j++)
        {
            auto ref_instr = --param_instr;

            auto arg = (*ref_instr)->getInstruction()->getArg1();
            if (arg->getType() == SAPFOR::CFG_ARG_TYPE::REG)
            {
                extract_vars_from_reg(worklist, arg, ref_instr, first_instr);
            }
            else if (arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR && arg->getMemType() == SAPFOR::CFG_MEM_TYPE::LOCAL_)
            {
                std::cout << "worklist add: " << arg->getValue() << std::endl;          //DEBUG PRINT
                worklist.insert(arg);
            }
        }
    }
    lookup_for_vars(where_to_add,worklist, instr, bblock, fullIR);
}

static void handle_single_loop(std::map<SgStatement*, std::string>& where_to_add,
                               SgStatement* loop_stmt,
                               const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR)
{
    auto [func_name, instr, bblock] = stmtToIR(fullIR, loop_stmt);
    std::cout << "bblock: " << bblock->getNumber() << " instr: " << instr->getNumber() << std::endl;

    auto cur_instr = bblock->getInstructions().end() - 1;

    set<SAPFOR::Argument*> worklist;
    extract_vars_from_reg(worklist, (*cur_instr)->getInstruction()->getResult(), cur_instr, bblock->getInstructions().begin());

    lookup_for_vars(where_to_add, worklist, (*cur_instr)->getInstruction(), bblock, fullIR);
}

void
findParameters(ResultSet& foundParameters,
               std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR,
               const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays)
{
    map<SgStatement*, string> where_to_add;

    map<string, FuncInfo*> name_to_func;
    for (const auto& [func, _] : fullIR)
        name_to_func[func->funcName] = func;

    map<FuncInfo*, vector<SAPFOR::Instruction*>> call_sites;
    for (auto& [func, bblocks] : fullIR)
    {
        for (const auto& block : bblocks)
        {
            for (const auto& ir_block : block->getInstructions())
            {
                auto instr = ir_block->getInstruction();
                if (instr->getOperation() == SAPFOR::CFG_OP::F_CALL)
                {
                    auto func_name = instr->getArg1()->getValue();
                    auto func_info = name_to_func.find(func_name);

                    if (func_info != name_to_func.end())
                        call_sites[func_info->second].push_back(instr);
                }
            }
        }

        SAPFOR::buildDominatorTreeLT(bblocks);
        for (auto block : bblocks)
        {
            if (block->getIdom() != NULL)
                std::cout << "BB: " << block->getNumber() << " IDOM: " << block->getIdom()->getNumber() << std::endl;
        }
        std::cout << "+++++++++++\n";
    }

    std::set<SgStatement*> alloc_statements;
    for (const auto& elem : declaredArrays)
    {
        const auto& array = elem.second.first;
        SgSymbol* arraySymb = array->GetDeclSymbol()->GetOriginal();
        SgStatement* decl = declaratedInStmt(arraySymb);

        for (auto& stmt : getAttributes<SgStatement*, SgStatement*>(decl, set<int>{ ALLOCATE_STMT }))
            alloc_statements.insert(stmt);
    }

    for (const auto& alloc_statement : alloc_statements)
    {
        handle_single_allocate(where_to_add, alloc_statement, fullIR);
    }

    set<SgStatement*> for_statements;
    // Find all FOR statements in the program
    for (const auto& [func, bblocks] : fullIR)
        for (const auto& block : bblocks)
            for (auto instr = block->getInstructions().begin(); instr != block->getInstructions().end(); ++instr)
            {
                auto op = (*instr)->getInstruction()->getOperator();
                if (op && op->variant() == FOR_NODE) {
                    std::cout << block->getNumber() << std::endl;
                    for_statements.insert(op);
                }
            }

    for (const auto& stmt : for_statements)
    {
        handle_single_loop(where_to_add, stmt, fullIR);
    }

    for (const auto& [stmt_before, var_name] : where_to_add)
    {
        // SgVariableSymb* var_symb = new SgVariableSymb(var_name.c_str());
        // SgVarRefExp* var = new SgVarRefExp(var_symb);
        // SgValueExp* zero = new SgValueExp(0);
        // SgExprListExp* ex = new SgExprListExp();
        // ex->setLhs(new SgExpression(ASSGN_OP, var, zero));
        // SgStatement* toAdd = new SgStatement(SPF_PARAMETER_OP, NULL, NULL, ex, NULL, NULL);
        // stmt_before->insertStmtAfter(*toAdd, *stmt_before->controlParent());

        foundParameters.insert(make_tuple(stmt_before->fileName(), stmt_before->lineNumber(), var_name));
    }
}