/*******************************************************************************
 * Copyright (c) 2006 Oracle Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Cameron Bateman/Oracle - initial API and implementation
 *    
 ********************************************************************************/

package org.eclipse.jst.jsf.common.internal.types;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.jdt.core.Signature;

/**
 * Static utility class used to compare two CompositeTypes for compatability
 * 
 * @author cbateman
 * 
 */
public final class TypeComparator {
    private static class SignatureTestResult {
        /**
         * the diagnostic
         */
        private final Diagnostic diagnostic;
        /**
         * Measure of the probability that the tested signatures were meant to
         * match. Larger value means higher probability.
         */
        private final int matchQuality;

        /**
         * @param diagnostic
         * @param matchQuality -
         *            Measure of the probability that the tested signatures were
         *            meant to match. Larger value means higher probability.
         */
        public SignatureTestResult(final Diagnostic diagnostic,
                final int matchQuality) {
            super();
            this.diagnostic = diagnostic;
            this.matchQuality = matchQuality;
        }
    }

    private final TypeComparatorDiagnosticFactory   _factory;

    /**
     * Default Constructor
     * @param factory 
     */
    public TypeComparator(final TypeComparatorDiagnosticFactory factory) 
    {
        _factory = factory;
    }

    /**
     * @param firstType
     * @param secondType
     * @return true if firstType is assignable to secondType or vice-versa,
     *         depending on their assignment and runtime types
     */
    public Diagnostic calculateTypeCompatibility(
            final CompositeType firstType, final CompositeType secondType) {
        // first, box all primitives
        final CompositeType boxedFirstType = TypeTransformer
                .transformBoxPrimitives(firstType);
        final CompositeType boxedSecondType = TypeTransformer
                .transformBoxPrimitives(secondType);

        final String[] mustBeSatisfied = boxedFirstType.getSignatures();
        final String[] testSignatures = boxedSecondType.getSignatures();
        List<String> mustbeMethods = Collections.emptyList();
        List<String> mustbeTypes = Collections.emptyList();
        for (final String mustbeSignature : mustBeSatisfied) {
            if (TypeUtil.isMethodSignature(mustbeSignature)) {
                if (mustbeMethods.isEmpty()) {
                    mustbeMethods = new ArrayList<String>(mustbeSignature
                            .length());
                }
                mustbeMethods.add(mustbeSignature);
            } else {
                if (mustbeTypes.isEmpty()) {
                    mustbeTypes = new ArrayList<String>(mustbeSignature
                            .length());
                }
                mustbeTypes.add(mustbeSignature);
            }
        }
        final boolean mustbeWriteable = firstType.isLHS();
        SignatureTestResult bestResult = null;
        for (final String isSignature : testSignatures) {
            SignatureTestResult testResult;
            if (TypeUtil.isMethodSignature(isSignature)) {
                testResult = checkMethodSignature(isSignature, mustbeTypes,
                        mustbeMethods);
                if (testResult.diagnostic.getSeverity() == Diagnostic.OK) {
                    return testResult.diagnostic;
                }
            } else {
                testResult = checkTypeSignature(isSignature, mustbeTypes,
                        mustbeMethods, mustbeWriteable);
                if (testResult.diagnostic.getSeverity() == Diagnostic.OK) {
                    return checkAssignability(firstType, secondType);
                }
            }
            if (bestResult == null
                    || bestResult.matchQuality < testResult.matchQuality) {
                bestResult = testResult;
            }
        }
        // TODO: bestResult empty? (should not happen, but who knows...
        return bestResult.diagnostic;
    }

    private SignatureTestResult checkTypeSignature(
            final String isSignature, final List<String> mustbeTypes,
            final List<String> mustbeMethods, final boolean mustbeWriteable) {
        if (mustbeTypes.isEmpty()) {
            final Diagnostic diag = _factory.create_METHOD_EXPRESSION_EXPECTED();
            return new SignatureTestResult(diag, 0);
        }
        for (final String mustbeSignature : mustbeTypes) {
            if (mustbeSignature.equals(isSignature)
                    || canCoerce(isSignature, mustbeSignature, mustbeWriteable)) {
                final Diagnostic diag = Diagnostic.OK_INSTANCE;
                return new SignatureTestResult(diag, 5);
            }
        }
        final String[] params = new String[2];
        params[0] = readableSignatures(mustbeTypes);
        params[1] = Signature.toString(isSignature);
        final Diagnostic diag = _factory.create_INCOMPATIBLE_TYPES(params);
        return new SignatureTestResult(diag, 1);
    }

    private SignatureTestResult checkMethodSignature(
            final String isSignature, final List<String> mustbeTypes,
            final List<String> mustbeMethods) {
        if (mustbeMethods.isEmpty()) {
            final Diagnostic diag = _factory.create_VALUE_EXPRESSION_EXPECTED();
            return new SignatureTestResult(diag, 0);
        }
        for (final String mustbeSignature : mustbeMethods) {
            if (methodSignaturesMatch(mustbeSignature, isSignature)) {
                final Diagnostic diag = Diagnostic.OK_INSTANCE;
                return new SignatureTestResult(diag, 5);
            }
        }
        final String[] params = new String[2];
        params[0] = readableSignatures(mustbeMethods);
        params[1] = Signature
                .toString(isSignature, "method", null, false, true); //$NON-NLS-1$
        final Diagnostic diag = _factory.create_INCOMPATIBLE_METHOD_TYPES(params);
        return new SignatureTestResult(diag, 1);
    }

    private static String readableSignatures(final List<String> signatures) {
        StringBuilder res = null;
        for (final String sig : signatures) {
            String sigText;
            if (TypeUtil.isMethodSignature(sig)) {
                sigText = Signature.toString(sig, "method", null, false, true); //$NON-NLS-1$
            } else {
                sigText = Signature.toString(sig);
            }
            if (res == null) {
                res = new StringBuilder(sigText);
            } else {
                res.append(", ").append(sigText); //$NON-NLS-1$
            }
        }
        return res != null ? res.toString() : "[no signature]"; //$NON-NLS-1$
    }

    private static boolean canCoerce(final String testType,
            final String checkType, final boolean checkTypeIsWritable) {
        boolean canCoerce = canCoerce(testType, checkType);

        // if the check type is writable, we need to be sure that the
        // coercion can work in both directions
        if (canCoerce && checkTypeIsWritable) {
            // reverse roles: can checkType assign back to test type?
            canCoerce &= canCoerce(checkType, testType);
        }

        return canCoerce;
    }

    private static boolean canCoerce(final String testType,
            final String checkType) {
        // can always to coerce to string or object
        if (TypeCoercer.typeIsString(checkType)
                || TypeConstants.TYPE_JAVAOBJECT.equals(checkType)) 
        {
            return true;
        } else if (TypeCoercer.typeIsNumeric(checkType)) {
            return canCoerceNumeric(testType);
        } else if (TypeCoercer.typeIsBoolean(checkType)) {
            return TypeCoercer.canCoerceToBoolean(testType);
        }

        // otherwise, no type coercion available
        return false;
    }

    private static boolean canCoerceNumeric(final String testType) {
        try {
            TypeCoercer.coerceToNumber(testType);
            // TODO: there is a case when coerceToNumber returns
            // null meaning "not sure", that we may want to handle
            // differently, with a warning
            return true;
        } catch (final TypeCoercionException tce) {
            // outright failure -- can't coerce
            return false;
        }
    }

    private static boolean methodSignaturesMatch(final String firstMethodSig,
            final String secondMethodSig) {
        // TODO: need to account for primitive type coercions
        if (firstMethodSig.equals(secondMethodSig)) {
            return true;
        }
        final String[] firstMethodParams = Signature
                .getParameterTypes(firstMethodSig);
        final String[] secondMethodParams = Signature
                .getParameterTypes(secondMethodSig);

        // fail fast if param count doesn't match
        if (firstMethodParams.length != secondMethodParams.length) {
            return false;
        }

        // now check each parameter
        for (int i = 0; i < firstMethodParams.length; i++) {
            // need to box primitives before comparing
            final String firstMethodParam = TypeTransformer
                    .transformBoxPrimitives(firstMethodParams[i]);
            final String secondMethodParam = TypeTransformer
                    .transformBoxPrimitives(secondMethodParams[i]);

            if (!firstMethodParam.equals(secondMethodParam)) {
                return false;
            }
        }

        // if we get to here then we need only check the return type
        final String firstReturn = TypeTransformer
                .transformBoxPrimitives(Signature.getReturnType(firstMethodSig));
        final String secondReturn = TypeTransformer
                .transformBoxPrimitives(Signature
                        .getReturnType(secondMethodSig));

        if (!firstReturn.equals(secondReturn)) {
            return false;
        }

        // if we get to here, then everything checks out
        return true;
    }

    /**
     * Precond: both firstType and secondType must represent value bindings.
     * 
     * @param firstType
     * @param secondType
     * @return a diagnostic validating that the two composite have compatible
     *         assignability
     */
    private Diagnostic checkAssignability(final CompositeType firstType,
            final CompositeType secondType) {
        if (firstType.isRHS() && !secondType.isRHS()) {
            return _factory.create_PROPERTY_NOT_READABLE();
        }

        if (firstType.isLHS() && !secondType.isLHS()) {
            return _factory.create_PROPERTY_NOT_WRITABLE();
        }

        return Diagnostic.OK_INSTANCE;
    }
}