package visitor.codegeneration;

import ast.Program;
import ast.definition.classes.FuncDefinition;
import ast.definition.classes.VarDefinition;
import ast.expression.classes.*;
import ast.statement.classes.*;
import ast.type.RecordField;
import ast.type.classes.*;
import visitor.Visitor;

public abstract class AbstractCGVisitor<TP, TR> implements Visitor<TP, TR> {

    protected CodeGenerator cg;
    protected ValueCGVisitor valueCGVisitor = null;
    protected AddressCGVisitor addressCGVisitor = null;
    protected ExecuteCGVisitor executeCGVisitor = null;

    protected AbstractCGVisitor(CodeGenerator cg) {
        this.cg = cg;
    }

    @Override
    public TR visit(Program ast, TP param) {
        assert false : "Undefined template visit(Program) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(VoidType ast, TP param) {
        assert false : "Undefined template visit(VoidType) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(RecordType ast, TP param) {
        assert false : "Undefined template visit(RecordType) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(IntType ast, TP param) {
        assert false : "Undefined template visit(IntType) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(FunctionType ast, TP param) {
        assert false : "Undefined template visit(FunctionType) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(ErrorType ast, TP param) {
        assert false : "Undefined template visit(ErrorType) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(DoubleType ast, TP param) {
        assert false : "Undefined template visit(DoubleType) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(CharType ast, TP param) {
        assert false : "Undefined template visit(CharType) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(ArrayType ast, TP param) {
        assert false : "Undefined template visit(ArrayType) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(RecordField ast, TP param) {
        assert false : "Undefined template visit(RecordField) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(Assignment ast, TP param) {
        assert false : "Undefined template visit(Assignment) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(IfElse ast, TP param) {
        assert false : "Undefined template visit(IfElse)for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(ReadStatement ast, TP param) {
        assert false : "Undefined template visit(ReadStatement) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(Return ast, TP param) {
        assert false : "Undefined template visit(Return) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(WhileLoop ast, TP param) {
        assert false : "Undefined template visit(WhileLoop) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(WriteStatement ast, TP param) {
        assert false : "Undefined template visit(WriteStatement) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(Arithmetic ast, TP param) {
        assert false : "Undefined template visit(Arithmetic) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(ArrayIndexing ast, TP param) {
        assert false : "Undefined template visit(ArrayIndexing) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(Cast ast, TP param) {
        assert false : "Undefined template visit(Cast) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(CharLiteral ast, TP param) {
        assert false : "Undefined template visit(CharLiteral) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(Comparison ast, TP param) {
        assert false : "Undefined template visit(Comparison) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(DoubleLiteral ast, TP param) {
        assert false : "Undefined template visit(DoubleLiteral) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(FieldAccess ast, TP param) {
        assert false : "Undefined template visit(FieldAccess) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(FunctionInvocation ast, TP param) {
        assert false : "Undefined template visit(FunctionInvocation) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(IntLiteral ast, TP param) {
        assert false : "Undefined template visit(IntLiteral) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(Logical ast, TP param) {
        assert false : "Undefined template visit(Logical) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(Negation ast, TP param) {
        assert false : "Undefined template visit(Negation) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(UnaryMinus ast, TP param) {
        assert false : "Undefined template visit(UnaryMinus) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(Variable ast, TP param) {
        assert false : "Undefined template visit(Variable) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(FuncDefinition ast, TP param) {
        assert false : "Undefined template visit(FuncDefinition) for the code function " + this.getClass().getName();
        return null;
    }

    @Override
    public TR visit(VarDefinition ast, TP param) {
        assert false : "Undefined template visit(VarDefinition) for the code function " + this.getClass().getName();
        return null;
    }

    public void setValueCGVisitor(ValueCGVisitor valueCGVisitor) {
        this.valueCGVisitor = valueCGVisitor;
    }

    public void setAddressCGVisitor(AddressCGVisitor addressCGVisitor) {
        this.addressCGVisitor = addressCGVisitor;
    }

    public void setExecuteCGVisitor(ExecuteCGVisitor executeCGVisitor) {
        this.executeCGVisitor = executeCGVisitor;
    }
}