/*
 * $Id$
 */

package edu.jas.application;


import org.apache.log4j.Logger;

import edu.jas.arith.Rational;
import edu.jas.poly.AlgebraicNumber;
import edu.jas.poly.AlgebraicNumberRing;
import edu.jas.poly.Complex;
import edu.jas.poly.ComplexRing;
import edu.jas.poly.GenPolynomialRing;
import edu.jas.root.RealAlgebraicNumber;
import edu.jas.root.RealAlgebraicRing;
import edu.jas.structure.GcdRingElem;
import edu.jas.structure.RingFactory;
import edu.jas.ufd.FactorAbstract;
import edu.jas.ufd.FactorAlgebraic;
import edu.jas.ufd.FactorComplex;
import edu.jas.ufd.FactorQuotient;
import edu.jas.ufd.Quotient;
import edu.jas.ufd.QuotientRing;
import edu.jas.ufdroot.FactorRealAlgebraic;


/**
 * Factorization algorithms factory. Select appropriate factorization engine
 * based on the coefficient types.
 * @author Heinz Kredel
 * @usage To create objects that implement the Factorization
 *        interface use the FactorFactory. It will select an
 *        appropriate implementation based on the types of polynomial
 *        coefficients C. To obtain an implementation use
 *        getImplementation(), it returns an object of a class
 *        which extends the FactorAbstract class which implements
 *        the Factorization interface.
 * 
 *        
 * Factorization<CT> engine;
 * engine = FactorFactory.<CT> getImplementation(cofac);
 * c = engine.factors(a);
 * 
 * 
 *        For example, if the coefficient type is BigInteger, the usage looks
 *        like
 * 
 *        
 * BigInteger cofac = new BigInteger();
 * Factorization<BigInteger> engine;
 * engine = FactorFactory.getImplementation(cofac);
 * Sm = engine.factors(poly);
 * 
 * 
 * @see edu.jas.ufd.Factorization#factors(edu.jas.poly.GenPolynomial P)
 * @see edu.jas.ufd.FactorFactory#getImplementation(edu.jas.structure.RingFactory
 *      P)
 */

public class FactorFactory extends edu.jas.ufd.FactorFactory {


    private static final Logger logger = Logger.getLogger(FactorFactory.class);


    /**
     * Protected factory constructor.
     */
    protected FactorFactory() {
    }


    /**
     * Determine suitable implementation of factorization algorithms, case
     * AlgebraicNumber<C>.
     * @param fac AlgebraicNumberRing<C>.
     * @param  coefficient type, e.g. BigRational, ModInteger.
     * @return factorization algorithm implementation.
     */
    public static > FactorAbstract> getImplementation(
                    AlgebraicNumberRing fac) {
        return new FactorAlgebraic(fac, FactorFactory. getImplementation(fac.ring.coFac));
    }


    /**
     * Determine suitable implementation of factorization algorithms, case
     * Complex<C>.
     * @param fac ComplexRing<C>.
     * @param  coefficient type, e.g. BigRational, ModInteger.
     * @return factorization algorithm implementation.
     */
    public static > FactorAbstract> getImplementation(ComplexRing fac) {
        return new FactorComplex(fac);
    }


    /**
     * Determine suitable implementation of factorization algorithms, case
     * Quotient<C>.
     * @param fac QuotientRing<C>.
     * @param  coefficient type, e.g. BigRational, ModInteger.
     * @return factorization algorithm implementation.
     */
    public static > FactorAbstract> getImplementation(QuotientRing fac) {
        return new FactorQuotient(fac, FactorFactory. getImplementation(fac.ring.coFac));
    }


    /**
     * Determine suitable implementation of factorization algorithms, case
     * recursive GenPolynomial<C>. Use recursiveFactors().
     * @param fac GenPolynomialRing<C>.
     * @param  coefficient type, e.g. BigRational, ModInteger.
     * @return factorization algorithm implementation.
     */
    public static > FactorAbstract getImplementation(GenPolynomialRing fac) {
        return getImplementation(fac.coFac);
    }


    /**
     * Determine suitable implementation of factorization algorithms, case
     * RealAlgebraicNumber<C>.
     * @param fac RealAlgebraicRing<C>.
     * @param  coefficient type, e.g. BigRational.
     * @return factorization algorithm implementation.
     */
    public static  & Rational> FactorAbstract> getImplementation(
                    RealAlgebraicRing fac) {
        return new FactorRealAlgebraic(fac,
                        FactorFactory.> getImplementation(fac.algebraic));
    }


    /**
     * Determine suitable implementation of factorization algorithms, case
     * RealAlgebraicNumber<C>.
     * @param fac RealAlgebraicRing<C>.
     * @param  coefficient type, e.g. BigRational.
     * @return factorization algorithm implementation.
     */
    @SuppressWarnings("unchecked")
    public static  & Rational> FactorAbstract> getImplementation(
                    edu.jas.application.RealAlgebraicRing fac) {
        edu.jas.root.RealAlgebraicRing rar = (edu.jas.root.RealAlgebraicRing) (Object) fac.realRing;
        return new FactorRealReal(fac,
                        FactorFactory.> getImplementation(rar));
    }


    /**
     * Determine suitable implementation of factorization algorithms, other
     * cases.
     * @param  coefficient type
     * @param fac RingFactory<C>.
     * @return factorization algorithm implementation.
     */
    @SuppressWarnings("unchecked")
    public static > FactorAbstract getImplementation(RingFactory fac) {
        logger.info("app factor factory = " + fac.getClass().getName());
        //System.out.println("fac_o = " + fac.getClass().getName());
        FactorAbstract/*raw type*/ufd = null;
        edu.jas.application.RealAlgebraicRing rrfac = null;
        RealAlgebraicRing rfac = null;
        AlgebraicNumberRing afac = null;
        ComplexRing cfac = null;
        QuotientRing qfac = null;
        GenPolynomialRing pfac = null;
        Object ofac = fac;
        if (ofac instanceof edu.jas.application.RealAlgebraicRing) {
            //System.out.println("rrfac_o = " + ofac);
            rrfac = (edu.jas.application.RealAlgebraicRing) ofac;
            //ofac = rrfac.realRing;
            ufd = new FactorRealReal/*raw */(
                            rrfac,
                            FactorFactory. getImplementation(rrfac.realRing));
        } else if (ofac instanceof edu.jas.root.RealAlgebraicRing) {
            //System.out.println("rfac_o = " + ofac);
            rfac = (edu.jas.root.RealAlgebraicRing) ofac;
            //ofac = rfac.algebraic;
            ufd = new FactorRealAlgebraic/*raw */(rfac,
                            FactorFactory.> getImplementation(rfac.algebraic));
        } else if (ofac instanceof ComplexRing) {
            cfac = (ComplexRing) ofac;
            afac = cfac.algebraicRing();
            ufd = new FactorComplex(cfac, FactorFactory. getImplementation(afac));
        } else if (ofac instanceof AlgebraicNumberRing) {
            //System.out.println("afac_o = " + ofac);
            afac = (AlgebraicNumberRing) ofac;
            //ofac = afac.ring.coFac;
            ufd = new FactorAlgebraic/*raw */(afac, FactorFactory. getImplementation(afac.ring.coFac));
        } else if (ofac instanceof QuotientRing) {
            //System.out.println("qfac_o = " + ofac);
            qfac = (QuotientRing) ofac;
            ufd = new FactorQuotient/*raw */(qfac, FactorFactory. getImplementation(qfac.ring.coFac));
        } else if (ofac instanceof GenPolynomialRing) {
            //System.out.println("qfac_o = " + ofac);
            pfac = (GenPolynomialRing) ofac;
            ufd = getImplementation(pfac.coFac);
        } else {
            //System.out.println("no fac = " + fac.getClass().getName());
            ufd = edu.jas.ufd.FactorFactory.getImplementation(fac);
            //return (FactorAbstract) ufd;
        }
        //logger.info("implementation = " + ufd);
        return (FactorAbstract) ufd;
    }

}