/*
 * Copyright 2005 JBoss Inc
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.drools.rule;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

import org.drools.base.ClassFieldAccessorCache;
import org.drools.base.ClassFieldAccessorStore;
import org.drools.common.DroolsObjectInputStream;
import org.drools.common.DroolsObjectOutputStream;
import org.drools.definition.process.Process;
import org.drools.definition.type.FactType;
import org.drools.facttemplates.FactTemplate;

/**
 * Collection of related <code>Rule</code>s.
 * 
 * @see Rule
 * 
 *
 * @version $Id: Package.java,v 1.1 2005/07/26 01:06:31 mproctor Exp $
 */
public class Package
    implements
    Externalizable {
    // ------------------------------------------------------------
    // Constants`
    // ------------------------------------------------------------

    private static final long              serialVersionUID = 510l;

    // ------------------------------------------------------------
    // Instance members
    // ------------------------------------------------------------

    /** Name of the pkg. */
    private String                         name;

    /** Set of all rule-names in this <code>Package</code>. */
    private Map<String,Rule>               rules;

    private Map<String, ImportDeclaration> imports;

    private Map<String, Function>          functions;

    private Set                            staticImports;

    private Map<String, String>            globals;

    private Map                            factTemplates;

    private Map<String, Process>           ruleFlows;

    // private JavaDialectData packageCompilationData;
    private DialectRuntimeRegistry         dialectRuntimeRegistry;

    private Map<String, TypeDeclaration>   typeDeclarations;

    private ClassFieldAccessorStore        classFieldAccessorStore;

    /**
     * This is to indicate the the package has no errors during the
     * compilation/building phase
     */
    private boolean                        valid            = true;

    /**
     * This will keep a summary error message as to why this package is not
     * valid
     */
    private String                         errorSummary;

    // ------------------------------------------------------------
    // Constructors
    // ------------------------------------------------------------

    /**
     * Default constructor - for Externalizable. This should never be used by a
     * user, as it will result in an invalid state for the instance.
     */
    public Package() {

    }

    /**
     * Construct.
     * 
     * @param name
     *            The name of this <code>Package</code>.
     */
    public Package(final String name) {
        this.name = name;
        this.imports = new HashMap<String, ImportDeclaration>();
        this.typeDeclarations = new HashMap<String, TypeDeclaration>();
        this.staticImports = Collections.EMPTY_SET;
        this.rules = new LinkedHashMap<String, Rule>();
        this.ruleFlows = Collections.EMPTY_MAP;
        this.globals = Collections.EMPTY_MAP;
        this.factTemplates = Collections.EMPTY_MAP;
        this.functions = Collections.EMPTY_MAP;
        this.dialectRuntimeRegistry = new DialectRuntimeRegistry();
        this.classFieldAccessorStore = new ClassFieldAccessorStore();
    }

    /**
     * Handles the write serialization of the Package. Patterns in Rules may
     * reference generated data which cannot be serialized by default methods.
     * The Package uses PackageCompilationData to hold a reference to the
     * generated bytecode. The generated bytecode must be restored before any
     * Rules.
     * 
     * @param stream
     *            out the stream to write the object to; should be an instance
     *            of DroolsObjectOutputStream or OutputStream
     */
    public void writeExternal(ObjectOutput stream) throws IOException {
        boolean isDroolsStream = stream instanceof DroolsObjectOutputStream;
        ByteArrayOutputStream bytes = null;
        ObjectOutput out;

        if ( isDroolsStream ) {
            out = stream;
        } else {
            bytes = new ByteArrayOutputStream();
            out = new DroolsObjectOutputStream( bytes );
        }
        out.writeObject( this.dialectRuntimeRegistry );
        out.writeObject( this.typeDeclarations );
        out.writeObject( this.name );
        out.writeObject( this.imports );
        out.writeObject( this.staticImports );
        out.writeObject( this.functions );
        out.writeObject( this.factTemplates );
        out.writeObject( this.ruleFlows );
        out.writeObject( this.globals );
        out.writeBoolean( this.valid );
        out.writeObject( this.rules );
        out.writeObject( this.classFieldAccessorStore );
        // writing the whole stream as a byte array
        if ( !isDroolsStream ) {
            bytes.flush();
            bytes.close();
            stream.writeObject( bytes.toByteArray() );
        }
    }

    /**
     * Handles the read serialization of the Package. Patterns in Rules may
     * reference generated data which cannot be serialized by default methods.
     * The Package uses PackageCompilationData to hold a reference to the
     * generated bytecode; which must be restored before any Rules. A custom
     * ObjectInputStream, able to resolve classes against the bytecode in the
     * PackageCompilationData, is used to restore the Rules.
     * 
     * @param stream,
     *            the stream to read data from in order to restore the object;
     *            should be an instance of DroolsObjectInputStream or
     *            InputStream
     */
    public void readExternal(ObjectInput stream) throws IOException,
                                                ClassNotFoundException {
        boolean isDroolsStream = stream instanceof DroolsObjectInputStream;
        DroolsObjectInputStream in = isDroolsStream ? (DroolsObjectInputStream) stream : new DroolsObjectInputStream( new ByteArrayInputStream( (byte[]) stream.readObject() ) );

        // setting parent classloader for dialect datas
        this.dialectRuntimeRegistry = (DialectRuntimeRegistry) in.readObject();

        this.typeDeclarations = (Map) in.readObject();
        this.name = (String) in.readObject();
        this.imports = (Map<String, ImportDeclaration>) in.readObject();
        this.staticImports = (Set) in.readObject();
        this.functions = (Map<String, Function>) in.readObject();
        this.factTemplates = (Map) in.readObject();
        this.ruleFlows = (Map) in.readObject();
        this.globals = (Map<String, String>) in.readObject();
        this.valid = in.readBoolean();
        this.rules = (Map<String, Rule>) in.readObject();
        this.classFieldAccessorStore = (ClassFieldAccessorStore) in.readObject();
        if ( !isDroolsStream ) {
            in.close();
        }
    }

    // ------------------------------------------------------------
    // Instance methods
    // ------------------------------------------------------------

    /**
     * Retrieve the name of this <code>Package</code>.
     * 
     * @return The name of this <code>Package</code>.
     */
    public String getName() {
        return this.name;
    }

    public DialectRuntimeRegistry getDialectRuntimeRegistry() {
        return this.dialectRuntimeRegistry;
    }

    public void addImport(final ImportDeclaration importDecl) {
        this.imports.put( importDecl.getTarget(),
                          importDecl );
    }

    public void removeImport(final String importEntry) {
        this.imports.remove( importEntry );
    }

    public Map<String, ImportDeclaration> getImports() {
        return this.imports;
    }

    public void addTypeDeclaration(final TypeDeclaration typeDecl) {
        this.typeDeclarations.put( typeDecl.getTypeName(),
                                   typeDecl );
    }

    public void removeTypeDeclaration(final String type) {
        this.typeDeclarations.remove( type );
    }

    public Map<String, TypeDeclaration> getTypeDeclarations() {
        return this.typeDeclarations;
    }

    public TypeDeclaration getTypeDeclaration(String type) {
        return this.typeDeclarations.get( type );
    }

    public void addStaticImport(final String functionImport) {
        if ( this.staticImports == Collections.EMPTY_SET ) {
            this.staticImports = new HashSet( 2 );
        }
        this.staticImports.add( functionImport );
    }

    public void addFunction(final Function function) {
        if ( this.functions == Collections.EMPTY_MAP ) {
            this.functions = new HashMap<String, Function>( 1 );
        }

        this.functions.put( function.getName(),
                            function );
        dialectRuntimeRegistry.getDialectData( function.getDialect() ).setDirty( true );
    }

    public Map<String, Function> getFunctions() {
        return this.functions;
    }

    public void removeFunctionImport(final String functionImport) {
        this.staticImports.remove( functionImport );
    }

    public Set getStaticImports() {
        return this.staticImports;
    }

    public void addGlobal(final String identifier,
                          final Class< ? > clazz) {
        if ( this.globals == Collections.EMPTY_MAP ) {
            this.globals = new HashMap<String, String>( 1 );
        }
        this.globals.put( identifier,
                          clazz.getName() );
    }

    public void removeGlobal(final String identifier) {
        this.globals.remove( identifier );
    }

    public Map<String, String> getGlobals() {
        return this.globals;
    }

    public void removeFunction(final String functionName) {
        Function function = this.functions.remove( functionName );
        if ( function != null ) {
            this.dialectRuntimeRegistry.removeFunction( this,
                                                        function );
        }
    }

    public FactTemplate getFactTemplate(final String name) {
        return (FactTemplate) this.factTemplates.get( name );
    }

    public void addFactTemplate(final FactTemplate factTemplate) {
        if ( this.factTemplates == Collections.EMPTY_MAP ) {
            this.factTemplates = new HashMap( 1 );
        }
        this.factTemplates.put( factTemplate.getName(),
                                factTemplate );
    }

    /**
     * Add a <code>Rule</code> to this <code>Package</code>.
     * 
     * @param rule
     *            The rule to add.
     * 
     * @throws DuplicateRuleNameException
     *             If the <code>Rule</code> attempting to be added has the
     *             same name as another previously added <code>Rule</code>.
     * @throws InvalidRuleException
     *             If the <code>Rule</code> is not valid.
     */
    public void addRule(final Rule rule) {
        final String name = rule.getName();

        this.rules.put( name,
                        rule );
        rule.setLoadOrder( this.rules.size() );
    }

    /**
     * Add a rule flow to this package.
     */
    public void addProcess(Process process) {
        if ( this.ruleFlows == Collections.EMPTY_MAP ) {
            this.ruleFlows = new HashMap();
        }
        this.ruleFlows.put( process.getId(),
                            process );
    }

    /**
     * Get the rule flows for this package. The key is the ruleflow id. It will
     * be Collections.EMPTY_MAP if none have been added.
     */
    public Map<String, Process> getRuleFlows() {
        return this.ruleFlows;
    }

    /**
     * Rule flows can be removed by ID.
     */
    public void removeRuleFlow(String id) {
        if ( !this.ruleFlows.containsKey( id ) ) {
            throw new IllegalArgumentException( "The rule flow with id [" + id + "] is not part of this package." );
        }
        this.ruleFlows.remove( id );
    }

    public void removeRule(final Rule rule) {
        this.rules.remove( rule.getName() );
        this.dialectRuntimeRegistry.removeRule( this,
                                                rule );
        // final String consequenceName =
        // rule.getConsequence().getClass().getName();
        //
        // Object object = this.dialectData.getDialectData( rule.getDialect() );
        //
        // // check for compiled code and remove if present.
        // if ( this.packageCompilationData.remove( consequenceName ) ) {
        // removeClasses( rule.getLhs() );
        //
        // // Now remove the rule class - the name is a subset of the
        // consequence name
        // this.packageCompilationData.remove( consequenceName.substring( 0,
        // consequenceName.indexOf( "ConsequenceInvoker" ) ) );
        // }
        // return this.packageCompilationData;
    }

    // private void removeClasses(final ConditionalElement ce) {
    // if ( ce instanceof GroupElement ) {
    // final GroupElement group = (GroupElement) ce;
    // for ( final Iterator it = group.getChildren().iterator(); it.hasNext(); )
    // {
    // final Object object = it.next();
    // if ( object instanceof ConditionalElement ) {
    // removeClasses( (ConditionalElement) object );
    // } else if ( object instanceof Pattern ) {
    // removeClasses( (Pattern) object );
    // }
    // }
    // } else if ( ce instanceof EvalCondition ) {
    // this.packageCompilationData.remove( ((EvalCondition)
    // ce).getEvalExpression().getClass().getName() );
    // }
    // }
    //
    // private void removeClasses(final Pattern pattern) {
    // for ( final Iterator it = pattern.getConstraints().iterator();
    // it.hasNext(); ) {
    // final Object object = it.next();
    // if ( object instanceof PredicateConstraint ) {
    // this.packageCompilationData.remove( ((PredicateConstraint)
    // object).getPredicateExpression().getClass().getName() );
    // } else if ( object instanceof ReturnValueConstraint ) {
    // this.packageCompilationData.remove( ((ReturnValueConstraint)
    // object).getExpression().getClass().getName() );
    // }
    // }
    // }

    /**
     * Retrieve a <code>Rule</code> by name.
     * 
     * @param name
     *            The name of the <code>Rule</code> to retrieve.
     * 
     * @return The named <code>Rule</code>, or <code>null</code> if not
     *         such <code>Rule</code> has been added to this
     *         <code>Package</code>.
     */
    public Rule getRule(final String name) {
        return (Rule) this.rules.get( name );
    }

    /**
     * Retrieve all <code>Rules</code> in this <code>Package</code>.
     * 
     * @return An array of all <code>Rules</code> in this <code>Package</code>.
     */
    public Rule[] getRules() {
        return (Rule[]) this.rules.values().toArray( new Rule[this.rules.size()] );
    }

    // public JavaDialectData getPackageCompilationData() {
    // return this.packageCompilationData;
    // }

    public String toString() {
        return "[Package name=" + this.name + "]";
    }

    /** Once this is called, the package will be marked as invalid */
    public void setError(final String summary) {
        this.errorSummary = summary;
        this.valid = false;
    }

    /**
     * @return true (default) if there are no build/structural problems.
     */
    public boolean isValid() {
        return this.valid;
    }

    /** This will throw an exception if the package is not valid */
    public void checkValidity() {
        if ( !isValid() ) {
            throw new InvalidRulePackage( this.getErrorSummary() );
        }
    }

    /**
     * This will return the error summary (if any) if the package is invalid.
     */
    public String getErrorSummary() {
        return this.errorSummary;
    }

    public boolean equals(final Object object) {
        if ( this == object ) {
            return true;
        }

        if ( object == null || !(object instanceof Package) ) {
            return false;
        }

        final Package other = (Package) object;

        return (this.name.equals( other.name ));
    }

    public int hashCode() {
        return this.name.hashCode();
    }

    /**
     * Returns true if clazz is imported as an Event class in this package
     * 
     * @param clazz
     * @return true if clazz is imported as an Event class in this package
     */
    public boolean isEvent(Class clazz) {
        if ( clazz == null ) {
            return false;
        }

        // check if clazz is resolved by any of the type declarations
        for ( TypeDeclaration type : this.typeDeclarations.values() ) {
            if ( type.matches( clazz ) && type.getRole() == TypeDeclaration.Role.EVENT ) {
                return true;
            }
        }

        return false;
    }

    public void clear() {
        this.rules.clear();
        this.dialectRuntimeRegistry.clear();
        this.ruleFlows.clear();
        this.imports.clear();
        this.functions.clear();
        this.staticImports.clear();
        this.globals.clear();
        this.factTemplates.clear();
        this.typeDeclarations.clear();
    }

    public FactType getFactType(final String typeName) {
        if ( typeName == null || ( this.name != null && !typeName.startsWith( this.name + "." ) ) ) {
            return null;
        }
        // in case the package name is != null, remove the package name from the
        // beginning of the type name
        String key = this.name == null ? typeName : typeName.substring( this.name.length() + 1 );
        TypeDeclaration decl = this.typeDeclarations.get( key );
        return decl != null ? decl.getTypeClassDef() : null;
    }

    public ClassFieldAccessorStore getClassFieldAccessorStore() {
        return classFieldAccessorStore;
    }

    public void setClassFieldAccessorCache(ClassFieldAccessorCache classFieldAccessorCache) {
        this.classFieldAccessorStore.setClassFieldAccessorCache( classFieldAccessorCache );
    }


}
