/*
 *                    BioJava development code
 *
 * This code may be freely distributed and modified under the
 * terms of the GNU Lesser General Public Licence.  This should
 * be distributed with the code.  If you do not have a copy,
 * see:
 *
 *      http://www.gnu.org/copyleft/lesser.html
 *
 * Copyright for this code is held jointly by the individual
 * authors.  These should be listed in @author doc comments.
 *
 * For more information on the BioJava project and its aims,
 * or to join the biojava-l mailing list, visit the home page
 * at:
 *
 *      http://www.biojava.org/
 *
 */
package org.biojavax.bio.phylo.io.nexus;

import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.biojava.bio.seq.io.ParseException;

/**
 * Represents Nexus characters blocks.
 * 
 * @author Richard Holland
 * @author Tobias Thierer
 * @author Jim Balhoff
 * @since 1.6
 */
public class CharactersBlock extends NexusBlock.Abstract {

        /**
         * A constant representing the name of Characters blocks.
         */
        public static final String CHARACTERS_BLOCK = "CHARACTERS";

        private int dimensionsNTax = 0;

        private int dimensionsNChar = 0;

        private String dataType = "STANDARD";

        private boolean respectCase = false;

        private String missing = "?";

        private String gap;

        private List symbols = new ArrayList();

        private Map equate = new LinkedHashMap(); // values are lists

        private String matchChar;

        private boolean labels = true;

        private boolean transposed = false;

        private boolean interleaved = false;

        private List items = new ArrayList();

        private String statesFormat = "STATESPRESENT";

        private boolean tokens = false;

        private int eliminateStart = 0;

        private int eliminateEnd = 0;

        private List taxLabels = new ArrayList();

        // map containing two-value arrays where second value is list
        private Map charStateLabels = new LinkedHashMap();

        private List charLabels = new ArrayList();

        private Map stateLabels = new LinkedHashMap(); // values are lists

        // values are lists, containing nested mix of strings and lists and sets
        private Map matrix = new LinkedHashMap();

        private List comments = new ArrayList();

        /**
         * Delegates to NexusBlock.Abstract constructor using
         * CharactersBlock.CHARACTERS_BLOCK as the name.
         */
        public CharactersBlock() {
                this(CharactersBlock.CHARACTERS_BLOCK);
        }

        /**
         * For the DATA block subclass.
         * 
         * @param replacementLabel
         *            the different label to use.
         */
        protected CharactersBlock(final String replacementLabel) {
                super(replacementLabel);
        }

        /**
         * Set the NTAX value.
         * 
         * @param dimensionsNTax
         *            the NTAX value.
         */
        public void setDimensionsNTax(int dimensionsNTax) {
                this.dimensionsNTax = dimensionsNTax;
        }

        /**
         * Get the NTAX value.
         * 
         * @return the NTAX value.
         */
        public int getDimensionsNTax() {
                return this.dimensionsNTax;
        }

        /**
         * Set the NCHAR value.
         * 
         * @param dimensionsNChar
         *            the NCHAR value.
         */
        public void setDimensionsNChar(int dimensionsNChar) {
                this.dimensionsNChar = dimensionsNChar;
        }

        /**
         * Get the NCHAR value.
         * 
         * @return the NCHAR value.
         */
        public int getDimensionsNChar() {
                return this.dimensionsNChar;
        }

        public void setDataType(final String dataType) {
                this.dataType = dataType;
        }

        public String getDataType() {
                return this.dataType;
        }

        public void setRespectCase(final boolean respectCase) {
                this.respectCase = respectCase;
        }

        public boolean isRespectCase() {
                return this.respectCase;
        }

        public void setMissing(final String missing) {
                this.missing = missing;
        }

        public String getMissing() {
                return this.missing;
        }

        public void setGap(final String gap) {
                this.gap = gap;
        }

        public String getGap() {
                return this.gap;
        }

        public void addSymbol(final String symbol) {
                if (!this.symbols.contains(symbol))
                        this.symbols.add(symbol);
        }

        public void removeSymbol(final String symbol) {
                this.symbols.remove(symbol);
        }

        public void removeAllSymbols() {
                this.symbols.clear();
        }

        public List getSymbols() {
                return this.symbols;
        }

        public void addEquate(final String symbol, final List symbols) {
                this.equate.put(symbol, symbols);
        }

        public void removeEquate(final String symbol) {
                this.equate.remove(symbol);
        }

        public Map getEquates() {
                return this.equate;
        }

        public void setMatchChar(final String matchChar) {
                this.matchChar = matchChar;
        }

        public String getMatchChar() {
                return this.matchChar;
        }

        public void setLabels(final boolean labels) {
                this.labels = labels;
        }

        public boolean isLabels() {
                return this.labels;
        }

        public void setTransposed(final boolean transposed) {
                this.transposed = transposed;
        }

        public boolean isTransposed() {
                return this.transposed;
        }

        public void setInterleaved(final boolean interleaved) {
                this.interleaved = interleaved;
        }

        public boolean isInterleaved() {
                return this.interleaved;
        }

        public void addItem(final String item) {
                if (!this.items.contains(item))
                        this.items.add(item);
        }

        public void removeItem(final String item) {
                this.items.remove(item);
        }

        public void removeAllItems() {
                this.items.clear();
        }

        public List getItems() {
                return this.items;
        }

        public void setStatesFormat(final String statesFormat) {
                this.statesFormat = statesFormat;
        }

        public String getStatesFormat() {
                return this.statesFormat;
        }

        public void setTokens(final boolean tokens) {
                this.tokens = tokens;
        }

        public boolean isTokens() {
                return this.tokens;
        }

        public void setEliminateStart(final int eliminateStart) {
                this.eliminateStart = eliminateStart;
        }

        public int getEliminateStart() {
                return this.eliminateStart;
        }

        public void setEliminateEnd(final int eliminateEnd) {
                this.eliminateEnd = eliminateEnd;
        }

        public int getEliminateEnd() {
                return this.eliminateEnd;
        }

        /**
         * Add a TAXLABEL. If it already exists, or is a number that refers to an
         * index position that already exists, an exception is thrown.
         * 
         * @param taxLabel
         *            the label to add.
         * @throws ParseException
         *             if the label cannot be added.
         */
        public void addTaxLabel(final String taxLabel) throws ParseException {
                if (this.taxLabels.contains(taxLabel))
                        throw new ParseException("Duplicate taxa label: " + taxLabel);
                else
                        try {
                                // Try it as a number to see if it refers to
                                // position we already have.
                                final int i = Integer.parseInt(taxLabel);
                                if (i <= this.taxLabels.size() + 1)
                                        throw new ParseException("Taxa label " + i
                                                        + " refers to already extant taxa position");
                        } catch (NumberFormatException e) {
                                // It is not a number, so ignore.
                        } catch (ParseException e) {
                                // Throw it.
                                throw e;
                        }
                this.taxLabels.add(taxLabel);
        }

        /**
         * Removes the given TAXLABEL.
         * 
         * @param taxLabel
         *            the label to remove.
         */
        public void removeTaxLabel(final String taxLabel) {
                this.taxLabels.remove(taxLabel);
        }

        /**
         * Checks to see if we contain the given TAXLABEL.
         * 
         * @param taxLabel
         *            the label to check for.
         * @return <tt>true</tt> if we already contain it.
         */
        public boolean containsTaxLabel(final String taxLabel) {
                if (this.taxLabels.contains(taxLabel))
                        return true;
                else
                        try {
                                // Try it as a number to see if it refers to
                                // position we already have.
                                final int i = Integer.parseInt(taxLabel);
                                if (i <= this.taxLabels.size() + 1)
                                        return true;
                        } catch (NumberFormatException e) {
                                // It is not a number, so ignore.
                        }
                return false;
        }

        /**
         * Get the TAXLABEL values added so far.
         * 
         * @return this labels so far.
         */
        public List getTaxLabels() {
                return this.taxLabels;
        }

        public void addCharState(final String charState) {
                this.charStateLabels.put(charState, new Object[] { null,
                                new ArrayList() });
        }

        public void setCharStateLabel(final String charState, final String label) {
                if (!this.charStateLabels.containsKey(charState))
                        this.addCharState(charState);
                ((Object[]) this.charStateLabels.get(charState))[0] = label;
        }

        public void addCharStateKeyword(final String charState, final String keyword) {
                if (!this.charStateLabels.containsKey(charState))
                        this.addCharState(charState);
                ((List) ((Object[]) this.charStateLabels.get(charState))[1])
                                .add(keyword);
        }

        public String getCharStateLabel(final String charState) {
                return (String) (((Object[]) this.charStateLabels.get(charState))[0]);
        }

        public List getCharStateLabelKeywords(final String charState) {
                return (List) (((Object[]) this.charStateLabels.get(charState))[1]);
        }

        public void removeCharState(final String charState) {
                this.charStateLabels.remove(charState);
        }

        public Set getAllCharStates() {
                return this.charStateLabels.keySet();
        }

        public void addCharLabel(final String charLabel) {
                this.charLabels.add(charLabel);
        }

        public void removeCharLabel(final String charLabel) {
                this.charLabels.remove(charLabel);
        }

        public boolean containsCharLabel(final String charLabel) {
                return this.charLabels.contains(charLabel);
        }

        public List getCharLabels() {
                return this.charLabels;
        }

        public void addState(final String state) {
                this.stateLabels.put(state, new ArrayList());
        }

        public void addStateLabel(final String state, final String label) {
                if (!this.stateLabels.containsKey(state))
                        this.addState(state);
                ((List) this.stateLabels.get(state)).add(label);
        }

        public List getStateLabels(final String state) {
                return (List) this.stateLabels.get(state);
        }

        public void removeState(final String state) {
                this.stateLabels.remove(state);
        }

        public void addMatrixEntry(final String taxa) {
                if (!this.matrix.containsKey(taxa))
                        this.matrix.put(taxa, new ArrayList());
        }

        public void appendMatrixData(final String taxa, final Object data) {
                ((List) this.matrix.get(taxa)).add(data);
        }

        public List getMatrixData(final String taxa) {
                return (List) this.matrix.get(taxa);
        }
        
        public Collection getMatrixLabels() {
                return Collections.unmodifiableSet(this.matrix.keySet());
        }

        /**
         * Adds a comment.
         * 
         * @param comment
         *            the comment to add.
         */
        public void addComment(final NexusComment comment) {
                this.comments.add(comment);
        }

        /**
         * Removes a comment.
         * 
         * @param comment
         *            the comment to remove.
         */
        public void removeComment(final NexusComment comment) {
                this.comments.remove(comment);
        }

        /**
         * Returns all comments.
         * 
         * @return all the selected comments.
         */
        public List getComments() {
                return this.comments;
        }

        protected void writeBlockContents(Writer writer) throws IOException {
                for (final Iterator i = this.comments.iterator(); i.hasNext();) {
                        ((NexusComment) i.next()).writeObject(writer);
                        writer.write(NexusFileFormat.NEW_LINE);
                }
                writer.write(" DIMENSIONS ");
                if (!this.taxLabels.isEmpty())
                        writer.write("NEWTAXA ");
                if (this.dimensionsNTax > 0)
                        writer.write("NTAX=" + this.dimensionsNTax + " ");
                writer.write("NCHAR=" + this.dimensionsNChar + ";"
                                + NexusFileFormat.NEW_LINE);

                writer.write(" FORMAT DATATYPE=");
                this.writeToken(writer, this.dataType);
                if (this.respectCase && "STANDARD".equals(this.dataType))
                        writer.write(" RESPECTCASE");
                writer.write(" MISSING=");
                this.writeToken(writer, this.missing);
                writer.write(" GAP=");
                this.writeToken(writer, this.gap);
                writer.write(" SYMBOLS=\"");
                if (this.symbols.isEmpty()) {
                        this.symbols.add("0");
                        this.symbols.add("1");
                }
                for (final Iterator i = this.symbols.iterator(); i.hasNext();)
                        this.writeToken(writer, (String) i.next());
                writer.write('"');
                if (!this.equate.isEmpty()) {
                        writer.write(" EQUATE=\"");
                        for (final Iterator i = this.equate.entrySet().iterator(); i
                                        .hasNext();) {
                                final Map.Entry entry = (Map.Entry) i.next();
                                this.writeToken(writer, "" + entry.getKey());
                                writer.write("=(");
                                for (final Iterator j = ((List) entry.getValue()).iterator(); j
                                                .hasNext();)
                                        this.writeToken(writer, "" + j.next());
                                writer.write(')');
                                if (i.hasNext())
                                        writer.write(' ');
                        }
                        writer.write('"');
                }
                if (this.matchChar != null) {
                        writer.write(" MATCHCHAR=");
                        this.writeToken(writer, this.matchChar);
                }
                writer.write(this.labels ? " LABELS" : " NOLABELS");
                if (this.transposed)
                        writer.write(" TRANSPOSED");
                // FIXME Output files, for now, are never interleaved.
                // if (this.interleaved)
                // writer.write(" INTERLEAVED");
                writer.write(" ITEMS=");
                if (this.items.isEmpty())
                        this.items.add("STATES");
                if (this.items.size() > 1)
                        writer.write('(');
                for (final Iterator i = this.items.iterator(); i.hasNext();) {
                        this.writeToken(writer, "" + i.next());
                        if (i.hasNext())
                                writer.write(' ');
                }
                if (this.items.size() > 1)
                        writer.write(')');
                writer.write(" STATESFORMAT=");
                this.writeToken(writer, this.statesFormat);
                final boolean reallyUseTokens = (this.tokens || "CONTINUOUS"
                                .equals(this.dataType))
                                && !("DNA".equals(this.dataType) || "RNA".equals(this.dataType) || "NUCLEOTIDE"
                                                .equals(this.dataType));
                writer.write(reallyUseTokens ? " TOKENS" : " NOTOKENS");
                writer.write(";" + NexusFileFormat.NEW_LINE);

                if (this.eliminateStart > 0 && this.eliminateEnd > 0) {
                        writer.write(" ELIMINATE " + this.eliminateStart + "-"
                                        + this.eliminateEnd);
                        writer.write(";" + NexusFileFormat.NEW_LINE);
                }

                if (this.taxLabels.size() > 0) {
                        writer.write(" TAXLABELS");
                        for (final Iterator i = this.taxLabels.iterator(); i.hasNext();) {
                                writer.write(' ');
                                this.writeToken(writer, (String) i.next());
                        }
                        writer.write(";" + NexusFileFormat.NEW_LINE);
                }

                if (!this.charStateLabels.isEmpty()
                                && !"CONTINUOUS".equals(this.dataType)) {
                        writer.write(" CHARSTATELABELS" + NexusFileFormat.NEW_LINE);
                        for (final Iterator i = this.charStateLabels.entrySet().iterator(); i
                                        .hasNext();) {
                                final Map.Entry topEntry = (Map.Entry) i.next();
                                writer.write('\t');
                                this.writeToken(writer, "" + topEntry.getKey());
                                writer.write('\t');
                                final Object[] parts = (Object[]) topEntry.getValue();
                                this.writeToken(writer, "" + parts[0]);
                                final List names = (List) parts[1];
                                if (!names.isEmpty()) {
                                        writer.write('/');
                                        for (final Iterator k = names.iterator(); k.hasNext();) {
                                                this.writeToken(writer, "" + k.next());
                                                if (k.hasNext())
                                                        writer.write(' ');
                                        }
                                }
                                if (!i.hasNext())
                                        writer.write(';');
                                else
                                        writer.write(',');
                                writer.write(NexusFileFormat.NEW_LINE);
                        }
                }

                if (!this.charLabels.isEmpty() && !this.transposed) {
                        writer.write(" CHARLABELS" + NexusFileFormat.NEW_LINE);
                        writer.write('\t');
                        for (final Iterator i = this.charLabels.iterator(); i.hasNext();) {
                                this.writeToken(writer, "" + i.next());
                                if (i.hasNext())
                                        writer.write(' ');
                        }
                        writer.write(";" + NexusFileFormat.NEW_LINE);
                }

                if (!this.stateLabels.isEmpty() && !"CONTINUOUS".equals(this.dataType)) {
                        writer.write(" STATELABELS" + NexusFileFormat.NEW_LINE);
                        for (final Iterator i = this.stateLabels.entrySet().iterator(); i
                                        .hasNext();) {
                                final Map.Entry topEntry = (Map.Entry) i.next();
                                writer.write('\t');
                                this.writeToken(writer, "" + topEntry.getKey());
                                writer.write('\t');
                                final List names = (List) topEntry.getValue();
                                for (final Iterator k = names.iterator(); k.hasNext();) {
                                        this.writeToken(writer, "" + k.next());
                                        if (k.hasNext())
                                                writer.write(' ');
                                }
                                if (!i.hasNext())
                                        writer.write(';');
                                else
                                        writer.write(',');
                                writer.write(NexusFileFormat.NEW_LINE);
                        }
                }

                // if statesformat=statespresent and items=1, bracket only multi values,
                // otherwise bracket all values
                // only space tokens if reallyUseTokens=true
                writer.write(" MATRIX" + NexusFileFormat.NEW_LINE);
                for (final Iterator i = this.matrix.entrySet().iterator(); i.hasNext();) {
                        final Map.Entry entry = (Map.Entry) i.next();
                        writer.write('\t');
                        this.writeToken(writer, "" + entry.getKey());
                        writer.write('\t');
                        for (final Iterator j = ((List) entry.getValue()).iterator(); j
                                        .hasNext();) {
                                this.writeMatrixEntry(writer, j.next(), reallyUseTokens);
                                if (reallyUseTokens && j.hasNext())
                                        writer.write(' ');
                        }
                        writer.write(NexusFileFormat.NEW_LINE);
                }
                writer.write(";" + NexusFileFormat.NEW_LINE);

        }

        private void writeMatrixEntry(final Writer writer, final Object obj,
                        final boolean reallyUseTokens) throws IOException {
                if (obj == null)
                        this.writeToken(writer, this.missing);
                else if (obj instanceof String)
                        this.writeToken(writer, (String) obj);
                else if (obj instanceof List) {
                        writer.write('(');
                        for (final Iterator k = ((List) obj).iterator(); k.hasNext();) {
                                this.writeMatrixEntry(writer, k.next(), reallyUseTokens);
                                if (k.hasNext() && reallyUseTokens)
                                        writer.write(' ');
                        }
                        writer.write(')');
                } else if (obj instanceof Set) {
                        writer.write('{');
                        for (final Iterator k = ((Set) obj).iterator(); k.hasNext();) {
                                this.writeMatrixEntry(writer, k.next(), reallyUseTokens);
                                if (k.hasNext() && reallyUseTokens)
                                        writer.write(' ');
                        }
                        writer.write('}');
                }
        }
}