#pragma once

#include<vector>
#include<map>
#include<unordered_set>

#include "../GraphLoop/graph_loops.h"
#include "../CFGraph/CFGraph.h"


struct ArrayDimension 
{
    uint64_t start, step, tripCount;
};

class AccessingSet {
    private:
        std::vector<std::vector<ArrayDimension>> allElements;

    public:
        AccessingSet(std::vector<std::vector<ArrayDimension>> input) : allElements(input) {};
        AccessingSet() {};
        std::vector<std::vector<ArrayDimension>> GetElements() const;
        void Insert(const std::vector<ArrayDimension>& element);
        AccessingSet Union(const AccessingSet& source);
        AccessingSet Intersect(const AccessingSet& secondSet) const;
        AccessingSet Diff(const AccessingSet& secondSet) const;
        bool ContainsElement(const std::vector<ArrayDimension>& element) const;        
        void FindCoveredBy(const std::vector<ArrayDimension>& element, std::vector<std::vector<ArrayDimension>>& result) const;
        void FindUncovered(const std::vector<ArrayDimension>& element, std::vector<std::vector<ArrayDimension>>& result) const;
        friend bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs);
};

using ArrayAccessingIndexes = std::map<std::string, AccessingSet>;

class Region: public SAPFOR::BasicBlock {
    public:
        Region() 
        {
            header = nullptr; 
        }

        Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block)
        {
            header = nullptr;
        }

        Region(LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*>& Blocks);

        Region* getHeader()
        {
            return header;
        }

        std::unordered_set<Region*>& getBasickBlocks()
        {
            return basickBlocks;
        }

        void addBasickBlocks(Region* region)
        {
            basickBlocks.insert(region);
        }
        std::unordered_set<Region*> getPrevRegions()
        {
            return prevRegions;
        }

        std::unordered_set<Region*> getNextRegions()
        {
            return nextRegions;
        }

        void addPrevRegion(Region* region) 
        {
            prevRegions.insert(region);
        }

        void addNextRegion(Region* region) 
        {
            nextRegions.insert(region);
        }

        void replaceInPrevRegions(Region* source, Region* destination)
        {
            prevRegions.erase(destination);
            prevRegions.insert(source);
        }

        void replaceInNextRegions(Region* source, Region* destination)
        {
            nextRegions.erase(destination);
            nextRegions.insert(source);
        }

        std::unordered_set<Region*> getSubRegions()
        {
            return subRegions;
        }

        void addSubRegions(Region* region)
        {
            subRegions.insert(region);
        }

        ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv;
            
    private:
        std::unordered_set<Region*> subRegions, basickBlocks;
        /*next Region which is BB for current BB Region*/
        std::unordered_set<Region*> nextRegions;
        /*prev Regions which is BBs for current BB Region*/
        std::unordered_set<Region*> prevRegions;
        Region* header;      
};


void Collapse(Region* region);
std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
void GetDimensionInfo(LoopGraph* loop, std::map<DIST::Array*, std::vector<std::vector<ArrayDimension>>>& loopDimensionsInfo, int level);
std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);