package org.simantics.scl.compiler.elaboration.chr;

import java.util.ArrayList;

import org.cojen.classfile.TypeDesc;
import org.simantics.scl.compiler.compilation.CompilationContext;
import org.simantics.scl.compiler.constants.BooleanConstant;
import org.simantics.scl.compiler.constants.Constant;
import org.simantics.scl.compiler.constants.IntegerConstant;
import org.simantics.scl.compiler.constants.JavaConstructor;
import org.simantics.scl.compiler.constants.JavaMethod;
import org.simantics.scl.compiler.constants.generic.CallJava;
import org.simantics.scl.compiler.constants.generic.MethodRef.FieldRef;
import org.simantics.scl.compiler.constants.generic.MethodRef.SetFieldRef;
import org.simantics.scl.compiler.elaboration.chr.analysis.UsageAnalysis;
import org.simantics.scl.compiler.elaboration.chr.plan.CHRSearchPlan;
import org.simantics.scl.compiler.elaboration.chr.plan.PlanRealizer;
import org.simantics.scl.compiler.elaboration.chr.relations.CHRConstraint;
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
import org.simantics.scl.compiler.elaboration.expressions.Variable;
import org.simantics.scl.compiler.elaboration.expressions.VariableProcedure;
import org.simantics.scl.compiler.errors.Locations;
import org.simantics.scl.compiler.internal.codegen.chr.CHRCodeGenerationConstants;
import org.simantics.scl.compiler.internal.codegen.chr.CHRRuntimeRulesetCodeGenerator;
import org.simantics.scl.compiler.internal.codegen.references.BoundVar;
import org.simantics.scl.compiler.internal.codegen.references.IVal;
import org.simantics.scl.compiler.internal.codegen.types.StandardTypeConstructor;
import org.simantics.scl.compiler.internal.codegen.writer.CodeWriter;
import org.simantics.scl.compiler.internal.parsing.Symbol;
import org.simantics.scl.compiler.types.TCon;
import org.simantics.scl.compiler.types.TVar;
import org.simantics.scl.compiler.types.Type;
import org.simantics.scl.compiler.types.Types;

import gnu.trove.map.hash.TObjectIntHashMap;
import gnu.trove.set.hash.THashSet;
import gnu.trove.set.hash.TIntHashSet;

public class CHRRuleset extends Symbol {
    
    public static final String INIT_CONSTRAINT = "__INIT__";
    
    public ArrayList<CHRConstraint> constraints = new ArrayList<CHRConstraint>();
    public ArrayList<CHRRule> rules = new ArrayList<CHRRule>();
    
    public CHRConstraint initConstraint;
    public int priorityCount;
    
    public String runtimeRulesetName;
    public TCon runtimeRulesetType;
    public BoundVar runtimeRulesetVariable;
    public TypeDesc runtimeRulesetTypeDesc;
    public Constant readCurrentId;
    public Constant writeCurrentId;
    
    // FIXME remove and change the parameter of Expression.toVal
    private CompilationContext cachedContext;
    
    // For code generation
    public BoundVar this_;
    public BoundVar[] parameters;
    public TypeDesc[] parameterTypeDescs;
    
    public CHRRuleset() {
        initConstraint = new CHRConstraint(Locations.NO_LOCATION, INIT_CONSTRAINT, Type.EMPTY_ARRAY);
        constraints.add(initConstraint);
    }
    
    public void resolve(TranslationContext context) {
        for(CHRConstraint constraint : constraints)
            context.newCHRConstraint(constraint.name, constraint);
        priorityCount = 0;
        for(CHRRule rule : rules) {
            rule.resolve(context);
            rule.priority = priorityCount++;
        }
        /*for(CHRConstraint constraint : constraints) {
            Variable newVariable = context.newVariable("claim" + constraint.factClassName);
        }*/
    }

    public void collectRefs(TObjectIntHashMap<Object> allRefs, TIntHashSet refs) {
        for(CHRRule rule : rules)
            rule.collectRefs(allRefs, refs);
    }

    public void checkType(TypingContext context) {
        for(CHRRule rule : rules)
            rule.checkType(context);
    }

    public void collectVars(TObjectIntHashMap<Variable> allVars, TIntHashSet vars) {
        for(CHRRule rule : rules)
            rule.collectVars(allVars, vars);
    }

    public void forVariables(VariableProcedure procedure) {
        for(CHRRule rule : rules)
            rule.forVariables(procedure);
    }

    public void collectFreeVariables(THashSet<Variable> vars) {
        for(CHRRule rule : rules)
            rule.collectFreeVariables(vars);
    }

    public void setLocationDeep(long loc) {
        if(location == Locations.NO_LOCATION) {
            this.location = loc;
            for(CHRRule rule : rules)
                rule.setLocationDeep(loc);
        }
    }

    public void compile(SimplificationContext context) {
        initializeCodeGeneration(context.getCompilationContext());
        UsageAnalysis.analyzeUsage(this);
        for(CHRRule rule : rules)
            rule.compile(context.getCompilationContext(), initConstraint);
        // remove init constraint if it is not useful
        if(initConstraint.minimumPriority == Integer.MAX_VALUE) {
            constraints.remove(0);
            initConstraint = null;
        }
    }

    public void simplify(SimplificationContext context) {
        for(CHRRule rule : rules)
            rule.simplify(context);
    }
    
    public void initializeCodeGeneration(CompilationContext context) {
        cachedContext = context; // FIXME remove
        
        String suffix = context.namingPolicy.getFreshClosureClassNameSuffix();
        runtimeRulesetType = Types.con(context.namingPolicy.getModuleName(), "CHR" + suffix);
        runtimeRulesetName = context.namingPolicy.getModuleClassName() + suffix;
        runtimeRulesetTypeDesc = TypeDesc.forClass(runtimeRulesetName);
        runtimeRulesetVariable = new BoundVar(runtimeRulesetType);
        for(CHRConstraint constraint : constraints)
            constraint.initializeCodeGeneration(context, this);
        readCurrentId = new CallJava(TVar.EMPTY_ARRAY, Types.PROC, Types.INTEGER, new Type[] {Types.CHRContext},
                null, new FieldRef(CHRCodeGenerationConstants.CHRContext_name, "currentId", CHRRuntimeRulesetCodeGenerator.FACT_ID_TYPE), null);
        writeCurrentId = new CallJava(TVar.EMPTY_ARRAY, Types.PROC, Types.UNIT, new Type[] {Types.CHRContext, Types.INTEGER},
                null, new SetFieldRef(CHRCodeGenerationConstants.CHRContext_name, "currentId", CHRRuntimeRulesetCodeGenerator.FACT_ID_TYPE), null);
        if(context.module != null) // for unit testing
            context.module.addTypeDescriptor(runtimeRulesetType.name, new StandardTypeConstructor(runtimeRulesetType, TVar.EMPTY_ARRAY, runtimeRulesetTypeDesc));
    }

    public static final Constant ACTIVATE = new JavaMethod(true, CHRCodeGenerationConstants.CHRContext_name, "activate", Types.PROC, Types.UNIT, Types.CHRContext, Types.INTEGER);
    private static final Constant CREATE_CHR_CONTEXT = new JavaConstructor("org/simantics/scl/runtime/chr/CHRContext", Types.PROC, Types.CHRContext);
    
    public void generateCode(CodeWriter w) {
        CHRRulesetObject object = new CHRRulesetObject(runtimeRulesetVariable, this);
        w.defineObject(object);
        for(CHRRule rule : rules) {
            for(CHRSearchPlan plan : rule.plans) {
                /*System.out.println("    plan " + plan.priority);
                for(PlanOp planOp : plan.ops)
                    System.out.println("        " + planOp);*/
                CodeWriter methodWriter = object.createMethod(w.getModuleWriter(), TVar.EMPTY_ARRAY, Types.PROC, Types.BOOLEAN, new Type[] {Types.CHRContext, plan.constraint.factType});
                plan.implementation = methodWriter.getFunction();
                IVal[] implementationParameters = methodWriter.getParameters();
                plan.activeFact.setVal(implementationParameters[1]);
                PlanRealizer realizer = new PlanRealizer(cachedContext, this, runtimeRulesetVariable, implementationParameters[0], plan.ops);
                realizer.nextOp(methodWriter);
                if(methodWriter.isUnfinished())
                    methodWriter.return_(BooleanConstant.TRUE);
            }
        }
        if(initConstraint != null) {
            IVal chrContext = w.apply(location, CREATE_CHR_CONTEXT);
            IVal initFact = w.apply(location, initConstraint.constructor, IntegerConstant.ZERO);
            w.apply(location, initConstraint.addProcedure, runtimeRulesetVariable, chrContext, initFact);
            w.apply(location, ACTIVATE, chrContext, new IntegerConstant(Integer.MAX_VALUE));
        }
    }

    public void collectEffects(THashSet<Type> effects) {
        for(CHRRule rule : rules) {
            for(CHRLiteral literal : rule.head.literals)
                literal.collectQueryEffects(effects);
            for(CHRLiteral literal : rule.head.literals)
                literal.collectEnforceEffects(effects);
        }
    }
}