/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/* 
 * File:   targetstatic.h
 * Author: pgess
 *
 * Created on July 2, 2016, 1:25 PM
 */

#ifndef TARGETSTATIC_H
#define TARGETSTATIC_H

#include "ast.h"
#include "pass/compilepass.h"
#include "compilation/targets.h"
#include "pass/interpretationpass.h"

namespace xreate{ namespace compilation {

class TargetInterpretation;
class InterpretationScope;
class InterpretationFunction;

    template <>
    struct TargetInfo<TargetInterpretation> {
        typedef Expression Result;
        typedef InterpretationScope Scope;
        typedef InterpretationFunction Function;
    };
    
class InterpretationScope: public  Scope<TargetInterpretation>{
    typedef Scope<TargetInterpretation> Parent;
    
public:
    InterpretationScope(CodeScope* scope, Function<TargetInterpretation>* f): Parent(scope, f) {}
    Expression process(const Expression& expression) override;
    
    llvm::Value* compile(const Expression& expression, const Context& context);
    
private:
    llvm::Value* compileHybrid(const InterpretationOperator& op, const Expression& expression, const Context& context);
    //llvm::Value* compilePartialFnCall(const Expression& expression, const Context& context);
    
    CodeScope* processOperatorIf(const Expression& expression);
    CodeScope* processOperatorSwitch(const Expression& expression);
};

class InterpretationFunction: public Function<TargetInterpretation>{
public:
    InterpretationFunction(const ManagedFnPtr& function, Target<TargetInterpretation>* target);
    Expression process(const std::vector<Expression>& args);
};

/*
 * Partially interpreted function signature
 */
struct PIFSignature{
    ManagedFnPtr declaration;
    std::vector<Expression> bindings;
};

class PIFunctionUnit;

class PIFunction: public InterpretationFunction{
public:
    PIFunctionUnit* functionUnit;
    PIFSignature signatureInstance;
    
    PIFunction(PIFSignature&& sig, size_t id, TargetInterpretation* target);
    llvm::Function* compile();
};

bool operator<(const PIFSignature& lhs, PIFunction* const rhs);
bool operator<(PIFunction* const lhs, const PIFSignature& rhs);

class TargetInterpretation: public Target<TargetInterpretation>{
public:    
    TargetInterpretation(AST* root, CompilePass* passCompilation): Target<TargetInterpretation>(root), pass(passCompilation){}

        //target:
public:
   InterpretationFunction* getFunction(FunctionUnit* unit);
   PIFunction* getFunction(PIFSignature&& sig);
   
private:
   std::map<PIFSignature, PIFunction*> __pifunctions;
   std::map<FunctionUnit*, InterpretationFunction*> __dictFunctionsByUnit;

        //self:
public:
    CompilePass* pass;
    llvm::Value* compile(const Expression& expression, const Context& ctx);
private:
    InterpretationScope* transformContext(const Context& c);
};

template<class Parent>
class InterpretationScopeDecorator: public Parent{
public:
    InterpretationScopeDecorator(CodeScope* codeScope, FunctionUnit* f, CompilePass* compilePass): Parent(codeScope, f, compilePass){}
    
    virtual llvm::Value* process(const Expression& expr, const std::string& hintVarDecl){
        const InterpretationData& data = Attachments::get<InterpretationData>(expr, {ANY, NONE});
        bool flagInterpretationEligible = (data.resolution == INTR_ONLY || data.op != InterpretationOperator::NONE);

        if (flagInterpretationEligible){
            Context ctx{this, this->function, this->pass};
            return Parent::pass->targetInterpretation->compile(expr, ctx);
        }
        
        return Parent::process(expr, hintVarDecl);
    }
};



} //end of compilation

struct InterpretationScopeDecoratorTag;

} //end of xreate

#endif /* TARGETSTATIC_H */


//transformers: 
//    template<> 
//    struct TransformerInfo<TargetInterpretation> {
//        static const int id = 1;
//    };