/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.apifest.boolcircuit;

/**

 */

public abstract class Circuit {

    /** Creates a simple Circuit that is associated with given input pin.

     * @since day2

     */

    public static Circuit input(int pin) {

        return new Input(pin);

    }

    /** Create circuit that inverts results of input circuit.

     */

    public static Circuit createNotCircuit(Circuit in) {

        return new Not(in);

    }

    public static Circuit createOrCircuit(Circuit in1, Circuit in2) {

        return new Binary(in1, in2, true);

    }

    public static Circuit createAndCircuit(Circuit in1, Circuit in2) {

        return new Binary(in1, in2, false);

    }

    public Circuit() {

    }

    public final boolean evaluate(Boolean ... inputs) {

        if (inputs == null) 

            throw new IllegalArgumentException();

        double[] vals = new double [inputs.length];

        for (int i = 0; i < inputs.length; i++) 

            vals[i] = inputs[i]? 1.0: 0.0;

        return evaluateFuzzy(vals) == 1.0;

    }

    public final double evaluateFuzzy(double ... inputs) {

        if (inputs == null) 

            throw new IllegalArgumentException();

        return doEvaluate(inputs);

    }

    protected abstract double doEvaluate(double ... inputs);

    public abstract int maxInputs();

    private interface OldEval {

        double doEvaluate1(int offset, double ... inputs);

    }

    private static class Input extends Circuit {

        int pin;

        Input(int pin) {

            this.pin = pin;

        }

        protected double doEvaluate(double ... inputs) {

            if (inputs == null || inputs.length < maxInputs()) 

                throw new IllegalArgumentException();

            return inputs[pin];

        }

        public  int maxInputs() {

            return pin + 1;

        }

    }

    private static class Not extends Circuit implements OldEval {

        private Circuit in;

        Not (Circuit in) {

            this.in = in;

        }

        public double doEvaluate(double ... inputs) {

            return doEvaluate1(0, inputs);

        }

        public double doEvaluate1(int i, double ... inputs) {

            if (in == null) {

                if (inputs == null || inputs.length < i + 1)

                    throw new IllegalArgumentException();

                return 1 - inputs[i];

            }

            if (in instanceof OldEval) {

                return 1 - ((OldEval)in).doEvaluate1(i, inputs[i]);

            }

            else {

                return 1 - in.evaluateFuzzy(inputs);

            }

        }

        public  int maxInputs() {

            return in != null? in.maxInputs(): 1;

        }

    }

    private static class Binary extends Circuit implements OldEval {

        private Circuit in1, in2;

        boolean or;

        Binary (Circuit in1, Circuit in2, boolean or) {

            this.in1 = in1;

            this.in2 = in2;

            this.or = or;

        }

        public double doEvaluate(double ... inputs) {

            return doEvaluate1(0, inputs);

        }

        public double doEvaluate1(int i, double ... inputs) {

            double x1, x2;

            if (in1 == null) {

                if (inputs == null || inputs.length < i + 1)

                    throw new IllegalArgumentException();

                x1 = inputs[i];

            } else {

                if (in1 instanceof OldEval) {

                    x1 = ((OldEval)in1).doEvaluate1(i, inputs);

                }

                else {

                    x1 = in1.evaluateFuzzy(inputs);

                }

            }

            if (in2 == null) {

                if (inputs == null || inputs.length < i + (in1 != null? in1.maxInputs(): 1) + 1)

                    throw new IllegalArgumentException();

                x2 = inputs[i + (in1 != null? in1.maxInputs(): 1)];

            } else {

                if (in2 instanceof OldEval) {

                    x2 = ((OldEval)in2).doEvaluate1(i + (in1 != null? in1.maxInputs(): 1), inputs);

                }

                else {

                    x2 = in2.evaluateFuzzy(inputs);

                }

            }

            return or? 1 - (1 - x1) * (1 - x2) : x1 * x2;

        }

        public  int maxInputs() {

            return (in1 != null? in1.maxInputs(): 1) + 

                    (in2 != null? in2.maxInputs(): 1) ;

        }

    }

}