/*
 * $Id$
 */

package edu.jas.poly;

import java.util.Random;
import java.util.List;
import java.util.ArrayList;
import java.io.Reader;

import org.apache.log4j.Logger;

import edu.jas.structure.ElemFactory;
import edu.jas.structure.RingElem;
import edu.jas.structure.RingFactory;
//import edu.jas.structure.GcdRingElem;
import edu.jas.structure.QuotPairFactory;


/**
 * Quotient ring factory using RingElem and RingFactory.
 * Objects of this class are immutable.
 * @author Heinz Kredel
 */
public class QuotientRing > 
             implements RingFactory>, QuotPairFactory> {

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

     private boolean debug = logger.isDebugEnabled();


    /** Ring factory of this factory. 
     */
    public final RingFactory< C > ring;


    /** The constructor creates a QuotientRing object 
     * from a RingFactory. 
     * @param r ring factory.
     */
    public QuotientRing(RingFactory r) {
        ring = r;
    }


    /**
     * Factory for base elements.
     */
    public RingFactory pairFactory() {
        return ring;
    }


    /**
     * Create from numerator.
     */
    public Quotient create(C n) {
        return new Quotient(this, n);
    }


    /**
     * Create from numerator, denominator pair.
     */
    public Quotient create(C n, C d) {
        return new Quotient(this, n, d);
    }


    /**
     * Is this structure finite or infinite.
     * @return true if this structure is finite, else false.
     * @see edu.jas.structure.ElemFactory#isFinite()
     */
    public boolean isFinite() {
        return ring.isFinite();
    }


    /** Copy Quotient element c.
     * @param c
     * @return a copy of c.
     */
    public Quotient copy(Quotient c) {
        return new Quotient( c.ring, c.num, c.den, true );
    }


    /** Get the zero element.
     * @return 0 as Quotient.
     */
    public Quotient getZERO() {
        return new Quotient( this, ring.getZERO() );
    }


    /**  Get the one element.
     * @return 1 as Quotient.
     */
    public Quotient getONE() {
        return new Quotient( this, ring.getONE() );
    }

    
    /**  Get a list of the generating elements.
     * @return list of generators for the algebraic structure.
     * @see edu.jas.structure.ElemFactory#generators()
     */
    public List> generators() {
        List rgens = ring.generators();
        List> gens = new ArrayList>( rgens.size() );
        for ( C c: rgens ) {
             gens.add( new Quotient(this,c) );
        }
        return gens;
    }


    /**
     * Query if this ring is commutative.
     * @return true if this ring is commutative, else false.
     */
    public boolean isCommutative() {
        return ring.isCommutative();
    }


    /**
     * Query if this ring is associative.
     * @return true if this ring is associative, else false.
     */
    public boolean isAssociative() {
        return ring.isAssociative();
    }


    /**
     * Query if this ring is a field.
     * @return true.
     */
    public boolean isField() {
        return true;
    }


    /**
     * Characteristic of this ring.
     * @return characteristic of this ring.
     */
    public java.math.BigInteger characteristic() {
        return ring.characteristic();
    }


    /** Get a Quotient element from a BigInteger value.
     * @param a BigInteger.
     * @return a Quotient.
     */
    public Quotient fromInteger(java.math.BigInteger a) {
        return new Quotient( this, ring.fromInteger(a) );
    }


    /** Get a Quotient element from a long value.
     * @param a long.
     * @return a Quotient.
     */
    public Quotient fromInteger(long a) {
        return new Quotient( this, ring.fromInteger(a) );
    }
    

    /** Get the String representation as RingFactory.
     * @see java.lang.Object#toString()
     */
    @Override
     public String toString() {
        return "Quotient[ " 
                + ring.toString() + " ]";
    }


    /** Get a scripting compatible string representation.
     * @return script compatible representation for this ElemFactory.
     * @see edu.jas.structure.ElemFactory#toScript()
     */
    @Override
    public String toScript() {
        // Python case
        return "QuotientRing(" + ring.toScript() + ")";
    }


    /** Comparison with any other object.
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    @SuppressWarnings("unchecked")
    public boolean equals(Object b) {
        if ( ! ( b instanceof QuotientRing ) ) {
           return false;
        }
        QuotientRing a = null;
        try {
            a = (QuotientRing) b;
        } catch (ClassCastException e) {
        }
        if ( a == null ) {
            return false;
        }
        return ring.equals( a.ring );
    }


    /** Hash code for this quotient ring.
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() { 
       int h;
       h = ring.hashCode();
       return h;
    }


    /** Quotient random.
     * @param n such that 0 ≤ v ≤ (2n-1).
     * @return a random residue element.
     */
    public Quotient random(int n) {
        C r = ring.random( n );
        C s = ring.random( n );
        while ( s.isZERO() ) {
            s = ring.random( n );
        }
        return new Quotient( this, r, s, false );
    }


    /** Quotient random.
     * @param n such that 0 ≤ v ≤ (2n-1).
     * @param rnd is a source for random bits.
     * @return a random residue element.
     */
    public Quotient random(int n, Random rnd) {
        C r = ring.random( n, rnd );
        C s = ring.random( n, rnd );
        while ( s.isZERO() ) {
            s = ring.random( n, rnd );
        }
        return new Quotient( this, r, s, false);
    }


    /** Parse Quotient from String.
     * @param s String.
     * @return Quotient from s.
     */
    public Quotient parse(String s) {
        C x = ring.parse( s );
        return new Quotient( this, x );
    }


    /** Parse Quotient from Reader.
     * @param r Reader.
     * @return next Quotient from r.
     */
    public Quotient parse(Reader r) {
        C x = ring.parse( r );
        if ( debug ) {
           logger.debug("x = " + x);
        }
        return new Quotient( this, x );
    }

}