EDIT

// $Id$

/**

* Copyright (C) 2016 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.molecular.io;

import info.bioinfweb.commons.bio.CharacterStateSetType;

import info.bioinfweb.commons.io.W3CXSConstants;

import info.bioinfweb.commons.text.StringUtils;

import info.bioinfweb.jphyloio.ReadWriteConstants;

import info.bioinfweb.jphyloio.ReadWriteParameterMap;

import info.bioinfweb.jphyloio.dataadapters.JPhyloIOEventReceiver;

import info.bioinfweb.jphyloio.dataadapters.MatrixDataAdapter;

import info.bioinfweb.jphyloio.dataadapters.ObjectListDataAdapter;

import info.bioinfweb.jphyloio.dataadapters.implementations.NoCharDefsNoSetsMatrixDataAdapter;

import info.bioinfweb.jphyloio.dataadapters.implementations.store.StoreObjectListDataAdapter;

import info.bioinfweb.jphyloio.events.CharacterSetIntervalEvent;

import info.bioinfweb.jphyloio.events.LinkedLabeledIDEvent;

import info.bioinfweb.jphyloio.events.SequenceTokensEvent;

import info.bioinfweb.jphyloio.events.TokenSetDefinitionEvent;

import info.bioinfweb.jphyloio.events.type.EventContentType;

import info.bioinfweb.jphyloio.utils.JPhyloIOWritingUtils;

import java.io.IOException;

import java.net.URI;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import javax.xml.namespace.QName;

import eu.etaxonomy.cdm.model.molecular.Sequence;

import eu.etaxonomy.cdm.model.molecular.SingleReadAlignment;

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

/**

 * In implementation of {@link MatrixDataAdapter} that delegates to a {@link Sequence} object.

 * <p>

 * Note that this adapter stores information on the {@link Sequence} in creation. Modifying the sequence or linked

 * objects will require to create a new instance of this class. Otherwise unexpected behavior may be the consequence.

 *

 * @author Ben Stöver

 * @date 29.04.2016

 */

public class CDMSequenceMatrixAdapter extends NoCharDefsNoSetsMatrixDataAdapter implements ReadWriteConstants, SingleReadAlignmentRDFXMLConstants {

    public static final String MATRIX_ID = DEFAULT_MATRIX_ID_PREFIX + "ContigAlignment";

    public static final String SINGLE_READ_SEQUENCE_ID_PREFIX = DEFAULT_SEQUENCE_ID_PREFIX + "SingleRead";

    public static final String CONSENSUS_SEQUENCE_ID= DEFAULT_SEQUENCE_ID_PREFIX + "Consensus";

    private Sequence sequence;

    private boolean exportConsensus;

    private List<SingleReadAlignment> singleReadList;

    private String consensusSequenceLabel;

    private ObjectListDataAdapter<TokenSetDefinitionEvent> tokenSetList;

    //TODO Also allow specifying single read labels?

    /**

     * Creates a new instance of this class.

     *

     * @param sequence the <i>CDM</i> sequence object containing the data to be exported

     * @param consensusSequenceLabel the label to be used for the consensus sequence (Maybe {@code null}.)

     * @param exportConsensus Specify {@code true} here, if the consensus sequence shall be included in the export or {@code false}

     *        otherwise.

     * @param exportSingleReads Specify {@code true} here, if the single reads shall be included in the export or {@code false}

     *        otherwise.

     * @throws IllegalArgumentException if both {@code exportConsensus} and {@code exportSingleReads} are {@code false}

     */

    public CDMSequenceMatrixAdapter(Sequence sequence, String consensusSequenceLabel, boolean exportConsensus, boolean exportSingleReads) {

        super();

        if (!exportConsensus && !exportSingleReads) {

            throw new IllegalArgumentException("Either exportConsensus or exportSingleReads must be true. "

                    + "Otherwise no sequences would be contained in this matrix.");

        }

        else {

            this.sequence = sequence;

            this.exportConsensus = exportConsensus;

            this.consensusSequenceLabel = consensusSequenceLabel;

            tokenSetList = createTokenSetList();

            if (exportSingleReads) {

                singleReadList = new ArrayList<SingleReadAlignment>(sequence.getSingleReadAlignments());  // Store references of single reads in defined order to allow random access.

                        //TODO Omit single reads that do not have an edited sequence yet?

            }

            else {

                singleReadList = Collections.emptyList();

            }

        }

    }

    private ObjectListDataAdapter<TokenSetDefinitionEvent> createTokenSetList() {

        StoreObjectListDataAdapter<TokenSetDefinitionEvent> result = new StoreObjectListDataAdapter<TokenSetDefinitionEvent>();

        final String id = ReadWriteConstants.DEFAULT_TOKEN_SET_ID_PREFIX;

        result.setObjectStartEvent(new TokenSetDefinitionEvent(CharacterStateSetType.DNA, id, null));

        long length = getColumnCount(null);  //TODO Change this expression, if column count should return -1 in the future.

        if (length > 0) {  // Empty character set interval events are not allowed.  //TODO Handle -1 separately

            result.getObjectContent(id).add(new CharacterSetIntervalEvent(0, length));

        }

        return result;

    }

    /**

     * @return the sequence

     */

    public Sequence getCDMSequence() {

        return sequence;

    }

    private int extractSingleReadIndexFromID(String sequenceID) {

        if (sequenceID.startsWith(SINGLE_READ_SEQUENCE_ID_PREFIX)) {

            try {

                return Integer.parseInt(sequenceID.substring(SINGLE_READ_SEQUENCE_ID_PREFIX.length()));

            }

            catch (NumberFormatException e) {}  // fall through

        }

        return -1;

    }

    @Override

    public LinkedLabeledIDEvent getStartEvent(ReadWriteParameterMap parameters) {

        return new LinkedLabeledIDEvent(EventContentType.ALIGNMENT, MATRIX_ID, "Contig alignment", null);

                //TODO Use label according to derivate and markers.

    }

    @Override

    public boolean containsLongTokens(ReadWriteParameterMap parameters) {

        return false;

    }

    @Override

    public long getColumnCount(ReadWriteParameterMap parameters) {

        return -1;  // Indicates that sequences may have different lengths. (Otherwise writing files without sequence elongation would not be possible.)

    }

    @Override

    public long getSequenceCount(ReadWriteParameterMap parameters) {

        int addend = 1;

        if (!exportConsensus) {

            addend = 0;

        }

        return singleReadList.size() + addend;

    }

    @Override

    public Iterator<String> getSequenceIDIterator(ReadWriteParameterMap parameters) {

        return new SequenceIDIterator(singleReadList.size(), exportConsensus);

    }

    @Override

    public long getSequenceLength(ReadWriteParameterMap parameters, String sequenceID) throws IllegalArgumentException {

        int singleReadIndex = extractSingleReadIndexFromID(sequenceID);

        if (singleReadIndex >= 0) {

            String sequence = singleReadList.get(singleReadIndex).getEditedSequence();

            if (sequence != null) {

                return sequence.length();

            }

            else {  // This would happen e.g. if not edited sequence was copied from pherogram yet.

                return 0;

            }

        }

        else if (exportConsensus && CONSENSUS_SEQUENCE_ID.equals(sequenceID)) {

            return getCDMSequence().getSequenceString().length();

        }

        else {

            throw new IllegalArgumentException("No sequence with the ID \"" + sequenceID + "\" could be found.");

        }

    }

    @Override

    public LinkedLabeledIDEvent getSequenceStartEvent(ReadWriteParameterMap parameters, String sequenceID) {

        int singleReadIndex = extractSingleReadIndexFromID(sequenceID);

        if (singleReadIndex >= 0) {

            return new LinkedLabeledIDEvent(EventContentType.SEQUENCE, sequenceID, "Single read " + singleReadIndex, null);

                    //TODO Use name displayed in derivate hierarchy or specified name as label instead?

        }

        else if (exportConsensus && CONSENSUS_SEQUENCE_ID.equals(sequenceID)) {

            return new LinkedLabeledIDEvent(EventContentType.SEQUENCE, sequenceID, consensusSequenceLabel, null);

        }

        else {

            throw new IllegalArgumentException("No sequence with the ID \"" + sequenceID + "\" could be found.");

        }

    }

    private void writeStringPart(JPhyloIOEventReceiver receiver, String string, long startColumn, long endColumn) throws IOException {

        if (string != null) {

            receiver.add(new SequenceTokensEvent(StringUtils.charSequenceToStringList(

                    string.substring((int)startColumn, (int)endColumn))));

        }

    }

    private String createMetadataID(String sequenceID, QName predicate) {

        return sequenceID + "META" + predicate.getLocalPart();

    }

    private void writeMetadataEvents(JPhyloIOEventReceiver receiver, String sequenceID, QName predicate, QName dataType, Object objectValue)

            throws IOException {

        if (objectValue != null) {

            JPhyloIOWritingUtils.writeSimpleLiteralMetadata(receiver, createMetadataID(sequenceID, predicate), null,

                    predicate, dataType, objectValue, null);

        }

    }

    @Override

    public void writeSequencePartContentData(ReadWriteParameterMap parameters, JPhyloIOEventReceiver receiver, String sequenceID,

            long startColumn, long endColumn) throws IOException, IllegalArgumentException {

        int singleReadIndex = extractSingleReadIndexFromID(sequenceID);

        if (singleReadIndex >= 0) {

            SingleReadAlignment singleRead = singleReadList.get(singleReadIndex);

            if (startColumn == 0) {

                writeMetadataEvents(receiver, sequenceID, PREDICATE_IS_SINGLE_READ, W3CXSConstants.DATA_TYPE_BOOLEAN, new Boolean(true));

                writeMetadataEvents(receiver, sequenceID, PREDICATE_IS_REVERSE_COMPLEMENTED, W3CXSConstants.DATA_TYPE_BOOLEAN, new Boolean(singleRead.isReverseComplement()));

                writeMetadataEvents(receiver, sequenceID, PREDICATE_HAS_LEFT_CUT_POSITION, W3CXSConstants.DATA_TYPE_INT, singleRead.getLeftCutPosition());

                writeMetadataEvents(receiver, sequenceID, PREDICATE_HAS_RIGHT_CUT_POSITION, W3CXSConstants.DATA_TYPE_INT, singleRead.getRightCutPosition());

                URI pherogramURI = AlignmentEditor.getPherogramURI(singleRead.getSingleRead());

                if (pherogramURI != null) {

                    JPhyloIOWritingUtils.writeTerminalResourceMetadata(receiver, createMetadataID(sequenceID, PREDICATE_HAS_PHEROGRAM),

                            null, PREDICATE_HAS_PHEROGRAM, pherogramURI);

                }

                writeMetadataEvents(receiver, sequenceID, PREDICATE_HAS_PHEROGRAM_ALIGNMENT, DATA_TYPE_PHERORAGM_ALIGNMENT, singleRead.getShifts());

                        //TODO This needs to be written with sequence type XML!

            }

            writeStringPart(receiver, singleRead.getEditedSequence(), startColumn, endColumn);

        }

        else if (exportConsensus && CONSENSUS_SEQUENCE_ID.equals(sequenceID)) {

            if (startColumn == 0) {

                writeMetadataEvents(receiver, sequenceID, PREDICATE_IS_CONSENSUS_SEQUENCE, W3CXSConstants.DATA_TYPE_BOOLEAN, new Boolean(true));

                //TODO Possibly export additional properties of sequence (e.g. isBarcode(), getDdbjId(), ...) as metadata?

            }

            writeStringPart(receiver, getCDMSequence().getSequenceString(), startColumn, endColumn);

        }

        else {

            throw new IllegalArgumentException("No sequence with the ID \"" + sequenceID + "\" could be found.");

        }

    }

    /* (non-Javadoc)

     * @see info.bioinfweb.jphyloio.dataadapters.implementations.NoSetsMatrixDataAdapter#getTokenSets()

     */

    @Override

    public ObjectListDataAdapter<TokenSetDefinitionEvent> getTokenSets(ReadWriteParameterMap parameters) {

        return tokenSetList;

    }

}