/*
 * 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 "compilation/targets.h"
#include "transformations.h"
#include "pass/interpretationpass.h"

namespace xreate{ namespace compilation {

class TargetInterpretation;
class InterpretationScope;
class InterpretatonFunction;

    template <>
    struct TargetInfo<TargetInterpretation> {
        typedef Expression Result;
        typedef InterpretationScope Scope;
        typedef InterpretatonFunction Function;
    };
    
    template<> 
    struct TransformerInfo<TargetInterpretation> {
        static const int id = 1;
    };

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 InterpretatonFunction: public Function<TargetInterpretation>{
    public:
        PIFSignature signature;
        
        InterpretatonFunction(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 TargetInterpretation: public Transformer, public Target<TargetInterpretation>{
public:    
    TargetInterpretation(AST* root): Target<TargetInterpretation>(root){}

        //transformer:
public:
    virtual llvm::Value* transform(const Expression& expression, llvm::Value* raw, const Context& ctx) override;
    virtual Expression transform(const Expression& expression, const Context& ctx) override;
    virtual bool isAcceptable(const Expression& expression) override;
    
        //target:
public:
    InterpretatonFunction* getFunction(const ManagedFnPtr& function);
private:
    std::set<InterpretationFunction*> __functions;

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

}}

#endif /* TARGETSTATIC_H */