EDIT

/**

* Copyright (C) 2014 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.editor.e4;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.net.URI;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.TreeMap;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.inject.Inject;

import org.biojava.bio.chromatogram.ChromatogramFactory;

import org.biojava.bio.chromatogram.UnsupportedChromatogramFormatException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.e4.ui.di.Focus;

import org.eclipse.e4.ui.di.Persist;

import org.eclipse.e4.ui.model.application.ui.MDirtyable;

import org.eclipse.swt.SWT;

import org.eclipse.swt.dnd.Clipboard;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.commands.ICommandService;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;

import eu.etaxonomy.cdm.model.media.MediaUtils;

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

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

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

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

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.molecular.TaxeditorMolecularPlugin;

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

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

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

import eu.etaxonomy.taxeditor.molecular.editor.e4.handler.ToggleInsertOverwriteHandlerE4;

import eu.etaxonomy.taxeditor.molecular.editor.e4.handler.ToggleLeftRightInsertionHandlerE4;

import eu.etaxonomy.taxeditor.molecular.l10n.Messages;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.view.derivateSearch.DerivateLabelProvider;

import info.bioinfweb.commons.swt.SWTUtils;

import info.bioinfweb.libralign.alignmentarea.AlignmentArea;

import info.bioinfweb.libralign.alignmentarea.selection.SelectionModel;

import info.bioinfweb.libralign.alignmentarea.tokenpainter.NucleotideTokenPainter;

import info.bioinfweb.libralign.dataarea.implementations.ConsensusSequenceArea;

import info.bioinfweb.libralign.dataarea.implementations.pherogram.PherogramArea;

import info.bioinfweb.libralign.dataarea.implementations.sequenceindex.SequenceIndexArea;

import info.bioinfweb.libralign.editsettings.EditSettingsChangeEvent;

import info.bioinfweb.libralign.editsettings.EditSettingsListener;

import info.bioinfweb.libralign.model.AlignmentModel;

import info.bioinfweb.libralign.model.AlignmentModelChangeListener;

import info.bioinfweb.libralign.model.adapters.StringAdapter;

import info.bioinfweb.libralign.model.events.SequenceChangeEvent;

import info.bioinfweb.libralign.model.events.SequenceRenamedEvent;

import info.bioinfweb.libralign.model.events.TokenChangeEvent;

import info.bioinfweb.libralign.model.implementations.PackedAlignmentModel;

import info.bioinfweb.libralign.model.tokenset.CharacterTokenSet;

import info.bioinfweb.libralign.model.tokenset.TokenSet;

import info.bioinfweb.libralign.model.utils.AlignmentModelUtils;

import info.bioinfweb.libralign.multiplealignments.AlignmentAreaList;

import info.bioinfweb.libralign.multiplealignments.MultipleAlignmentsContainer;

import info.bioinfweb.libralign.pherogram.model.PherogramAlignmentRelation;

import info.bioinfweb.libralign.pherogram.model.PherogramAreaModel;

import info.bioinfweb.libralign.pherogram.model.ShiftChange;

import info.bioinfweb.libralign.pherogram.provider.BioJavaPherogramProvider;

import info.bioinfweb.libralign.pherogram.provider.PherogramProvider;

import info.bioinfweb.libralign.pherogram.provider.ReverseComplementPherogramProvider;

import info.bioinfweb.tic.SWTComponentFactory;

/**

 * Editor component to edit a contig alignment used to combine different overlapping pherograms from Sanger sequencing to

 * a consensus sequence.

 * <p>

 * The contained GUI components used to edit the alignment come from <a href="http://bioinfweb.info/LibrAlign/">LibrAlign</a>.

 *

 * @author Ben Stöver

 * @author pplitzner

 * @date 04.08.2014

 */

public class AlignmentEditorE4 {

    public static final String ID = "eu.etaxonomy.taxeditor.molecular.AlignmentEditor"; //$NON-NLS-1$

	public static final int READS_AREA_INDEX = 1;

    public static final int EDITABLE_CONSENSUS_AREA_INDEX = READS_AREA_INDEX + 1;

    public static final int CONSENSUS_HINT_AREA_INDEX = EDITABLE_CONSENSUS_AREA_INDEX + 1;

	public static final int PHEROGRAM_AREA_INDEX = 0;

	public static final int CONSENSUS_DATA_AREA_INDEX = 0;

	public static final String DEFAULT_READ_NAME_PREFIX = "Read "; //$NON-NLS-1$

	public static final String CONSENSUS_NAME = "Consensus"; //$NON-NLS-1$

    private ConversationHolder conversationHolder;

	private final AlignmentModelChangeListener DIRTY_LISTENER = new AlignmentModelChangeListener() {

				@Override

				public <T> void afterTokenChange(TokenChangeEvent<T> e) {

					setDirty();

				}

				@Override

				public <T> void afterSequenceRenamed(SequenceRenamedEvent<T> e) {

					setDirty();

				}

				@Override

				public <T> void afterSequenceChange(SequenceChangeEvent<T> e) {

					setDirty();

				}

				@Override

				public <T, U> void afterProviderChanged(AlignmentModel<T> oldProvider,

						AlignmentModel<U> newProvider) {  // Not expected.

					setDirty();

				}

			};

	private final AlignmentEditorActionUpdater ACTION_UPDATER = new AlignmentEditorActionUpdater();

	public final Clipboard CLIPBOARD = new Clipboard(Display.getCurrent());  //TODO Move to global EDITor class.

    private MultipleAlignmentsContainer alignmentsContainer = null;

    private final Map<String, SingleReadAlignment> cdmMap = new TreeMap<String, SingleReadAlignment>();  //TODO Move this to ContigSequenceDataProvider

    @Inject

    private MDirtyable dirty;

    private AlignmentEditorInput input;

    @Inject

    public AlignmentEditorE4() {

    }

    private void refreshToolbarElement(String id) {

		ICommandService commandService =

				PlatformUI.getWorkbench().getActiveWorkbenchWindow().getService(ICommandService.class);

		if (commandService != null) {

			commandService.refreshElements(id, Collections.EMPTY_MAP);

		}

    }

    private void registerEditSettingListener(MultipleAlignmentsContainer container) {

        container.getEditSettings().addListener(new EditSettingsListener() {

            @Override

            public void workingModeChanged(EditSettingsChangeEvent e) {}  // Currently nothing to do

            @Override

            public void insertLeftInDataAreaChanged(EditSettingsChangeEvent e) {

                updateStatusBar();

                refreshToolbarElement(ToggleLeftRightInsertionHandlerE4.COMMAND_ID);

            }

            @Override

            public void insertChanged(EditSettingsChangeEvent e) {

                updateStatusBar();

                refreshToolbarElement(ToggleInsertOverwriteHandlerE4.COMMAND_ID);

            }

        });

    }

    private AlignmentArea createIndexArea(MultipleAlignmentsContainer container, AlignmentArea labeledArea) {

		AlignmentArea result = new AlignmentArea(container);

		result.setAllowVerticalScrolling(false);

		result.getDataAreas().getTopAreas().add(new SequenceIndexArea(result.getContentArea(), labeledArea));

		return result;

    }

    private AlignmentArea createEditableAlignmentArea(MultipleAlignmentsContainer container, boolean allowVerticalScrolling) {

		AlignmentArea result = new AlignmentArea(container);

		result.setAllowVerticalScrolling(allowVerticalScrolling);

		CharacterTokenSet tokenSet = CharacterTokenSet.newDNAInstance();  //TODO Should NUCLEOTIDE be used instead?

		AlignmentModel<Character> model = new PackedAlignmentModel<Character>(tokenSet);

		result.setAlignmentModel(model, false);

		model.getChangeListeners().add(DIRTY_LISTENER);

		result.getPaintSettings().getTokenPainterList().set(0, new NucleotideTokenPainter());

		return result;

	}

    private AlignmentArea createConsensusHintArea(MultipleAlignmentsContainer container,

    		AlignmentArea labeledArea) {

		AlignmentArea result = new AlignmentArea(container);

		result.setAllowVerticalScrolling(false);

		result.getDataAreas().getBottomAreas().add(

				new ConsensusSequenceArea(result.getContentArea(), labeledArea));

		return result;

    }

    private MultipleAlignmentsContainer getAlignmentsContainer() {

    	if (alignmentsContainer == null) {

    		alignmentsContainer = new MultipleAlignmentsContainer();

    		AlignmentAreaList list = alignmentsContainer.getAlignmentAreas();

    		AlignmentArea readsArea = createEditableAlignmentArea(alignmentsContainer, true);

    		readsArea.getSelection().addSelectionListener(ACTION_UPDATER);

    	    list.add(createIndexArea(alignmentsContainer, readsArea));

    		list.add(readsArea);  // Make sure READS_AREA_INDEX is correct.

    		AlignmentArea editableConsensusArea = createEditableAlignmentArea(alignmentsContainer, false);

    		editableConsensusArea.getSelection().addSelectionListener(ACTION_UPDATER);

    		list.add(editableConsensusArea);  // Make sure COMSENSUS_AREA_INDEX is correct.

    		list.add(createConsensusHintArea(alignmentsContainer, readsArea));

    		registerEditSettingListener(alignmentsContainer);

       	}

		return alignmentsContainer;

	}

    public AlignmentArea getReadsArea() {

    	return getAlignmentsContainer().getAlignmentAreas().get(READS_AREA_INDEX);

    }

    public AlignmentArea getEditableConsensusArea() {

    	return getAlignmentsContainer().getAlignmentAreas().get(EDITABLE_CONSENSUS_AREA_INDEX);

    }

    /**

     * Checks whether {@link #getReadsArea()} or {@link #getEditableConsensusArea()} currently

     * have the user focus and returns the according component.

     *

     * @return either the reads or the consensus alignment area or {@code null} if none of these

     *         components is currently focused

     */

    public AlignmentArea getFocusedArea() {

    	AlignmentArea result = getReadsArea();

    	if (hasFocus(result)) {

    		return result;

    	}

    	else {

    		result = getEditableConsensusArea();

        	if (hasFocus(result)) {

        		return result;

        	}

        	else {

        		return null;

        	}

    	}

    }

    /**

     * Checks whether the specified alignment area or one of its subcomponents currently has the

     * focus.

     *

     * @param area the alignment area to be checked (Can only be {@link #getReadsArea()} or

     *        {@link #getEditableConsensusArea()}.)

     * @return {@code true} if the specified component is focused and is either equal to

     *         {@link #getReadsArea()} or {@link #getEditableConsensusArea()}or {@code false} otherwise

     */

    private boolean hasFocus(AlignmentArea area) {

    	return SWTUtils.childHasFocus((Composite)area.getToolkitComponent());

    }

    public boolean hasPherogram(String sequenceID) {

        return getReadsArea().getDataAreas().getSequenceAreas(sequenceID).size() > PHEROGRAM_AREA_INDEX;

    }

    public PherogramArea getPherogramArea(String sequenceID) {

        if (hasPherogram(sequenceID)) {

            return (PherogramArea)getReadsArea().getDataAreas().getSequenceAreas(sequenceID).get(PHEROGRAM_AREA_INDEX);

        }

        else {

            return null;

        }

    }

    private ConsensusSequenceArea getConsensusHintDataArea() {

        return (ConsensusSequenceArea)getAlignmentsContainer().getAlignmentAreas().

                get(CONSENSUS_HINT_AREA_INDEX).getDataAreas().getBottomAreas().

                get(CONSENSUS_DATA_AREA_INDEX);

    }

    @Deprecated  //TODO Remove as soon as testing period is over

    private void createTestContents() {

		// Just for testing:

		try {

			addRead(new File("D:/Users/BenStoever/ownCloud/Dokumente/Projekte/EDITor/Quelltexte/LibrAlign branch/Repository/eu.etaxonomy.taxeditor.editor/src/main/resources/AlignmentTestData/JR430_JR-P01.ab1").toURI(), false); //$NON-NLS-1$

            //addRead(new File("D:/Users/BenStoever/ownCloud/Dokumente/Projekte/EDITor/Quelltexte/LibrAlign branch/Repository/eu.etaxonomy.taxeditor.editor/src/main/resources/AlignmentTestData/JR444_JR-P05.ab1").toURI(), false);

            addRead(new File("D:/Users/BenStoever/ownCloud/Dokumente/Projekte/EDITor/Quelltexte/LibrAlign branch/Repository/eu.etaxonomy.taxeditor.editor/src/main/resources/AlignmentTestData/Test_qualityScore.scf").toURI(), false); //$NON-NLS-1$

			// Add test consensus sequence:

			AlignmentModel consensusModel = getEditableConsensusArea().getAlignmentModel();

			String id = consensusModel.addSequence(CONSENSUS_NAME);

			Collection<Object> tokens = new ArrayList<Object>();  // First save tokens in a collection to avoid GUI updated for each token.

			tokens.add(consensusModel.getTokenSet().tokenByRepresentation("A")); //$NON-NLS-1$

			tokens.add(consensusModel.getTokenSet().tokenByRepresentation("C")); //$NON-NLS-1$

			tokens.add(consensusModel.getTokenSet().tokenByRepresentation("G")); //$NON-NLS-1$

			tokens.add(consensusModel.getTokenSet().tokenByRepresentation("T")); //$NON-NLS-1$

			consensusModel.insertTokensAt(id, 0, tokens);

		}

		catch (Exception e) {

			throw new RuntimeException(e);

		}

    }

    private void readCDMData(Sequence sequenceNode) {

    	//TODO If called from somewhere else than createPartControl() the editorInput needs to be checked and previous contents need to be cleared (or updated).

		// Add reads:

		for (SingleReadAlignment singleReadAlignment : sequenceNode.getSingleReadAlignments()) {

			try {

				SingleRead pherogramInfo = singleReadAlignment.getSingleRead();

				String id = addRead(DerivateLabelProvider.getDerivateText(pherogramInfo, conversationHolder),

						getPherogramURI(pherogramInfo),

						singleReadAlignment.isReverseComplement(),

						singleReadAlignment.getEditedSequence(),

						singleReadAlignment.getFirstSeqPosition(),

						singleReadAlignment.getLeftCutPosition(),

						singleReadAlignment.getRightCutPosition(),

						singleReadAlignment.getShifts());

				cdmMap.put(id, singleReadAlignment);

			}

			catch (Exception e) {  // Usually due to an error while trying to read the pherogram (e.g. due to an unsupported format or an invalid URI).

                MessagingUtils.errorDialog(Messages.AlignmentEditor_ERROR_SINGLE_READ, null, Messages.AlignmentEditor_ERROR_SINGLE_READ_MESSAGE +

                        e.getLocalizedMessage(), TaxeditorMolecularPlugin.PLUGIN_ID, e, false);

			}

		}

		// Set consensus sequence:

		AlignmentModel consensusModel = getEditableConsensusArea().getAlignmentModel();

		String id = consensusModel.addSequence(CONSENSUS_NAME);

		consensusModel.insertTokensAt(id, 0, AlignmentModelUtils.charSequenceToTokenList(

				sequenceNode.getConsensusSequence().getString(), consensusModel.getTokenSet()));

		//TODO Can the consensus sequence also be null? / Should it be created here, if nothing is in the DB?

    }

    @PostConstruct

    public void createPartControl(Composite parent) {

        if (CdmStore.isActive()){

            if(conversationHolder == null){

                conversationHolder = CdmStore.createConversation();

            }

        }

        else{

            return;

        }

        SWTComponentFactory.getInstance().getSWTComponent(getAlignmentsContainer(), parent, SWT.NONE);

        Display.getCurrent().addFilter(SWT.FocusIn, ACTION_UPDATER);

        Display.getCurrent().addFilter(SWT.FocusOut, ACTION_UPDATER);

	}

    @PreDestroy

    public void dispose() {

        Display.getCurrent().removeFilter(SWT.FocusIn, ACTION_UPDATER);

        Display.getCurrent().removeFilter(SWT.FocusOut, ACTION_UPDATER);

        CLIPBOARD.dispose();

        input.dispose();

        if(conversationHolder!=null){

            conversationHolder.close();

            conversationHolder = null;

        }

        if(input!=null){

            input.dispose();

        }

        dirty.setDirty(false);

    }

	private void updateStatusBar() {

	    //FIXME E4 migrate

//        IActionBars bars = getEditorSite().getActionBars();

//        bars.getStatusLineManager().setMessage(

//                Messages.AlignmentEditor_EDIT_MODE + (getReadsArea().getEditSettings().isInsert() ? Messages.AlignmentEditor_INSERT : Messages.AlignmentEditor_OVERWRITE) + "  " + //$NON-NLS-1$

//        		Messages.AlignmentEditor_INSERTION_PHEROGRAM +

//	       		(getReadsArea().getEditSettings().isInsertLeftInDataArea() ? Messages.AlignmentEditor_LEFT : Messages.AlignmentEditor_RIGHT));  //TODO multi language

    }

    private SingleReadAlignment.Shift[] convertToCDMShifts(PherogramAreaModel model) {

    	Iterator<ShiftChange> iterator = model.shiftChangeIterator();

    	List<SingleReadAlignment.Shift> shifts = new ArrayList<SingleReadAlignment.Shift>();

    	while (iterator.hasNext()) {

    		ShiftChange shiftChange = iterator.next();

    		shifts.add(new SingleReadAlignment.Shift(shiftChange.getBaseCallIndex(), shiftChange.getShiftChange()));

    	}

    	return shifts.toArray(new SingleReadAlignment.Shift[shifts.size()]);

    }

    @Persist

    public void doSave(IProgressMonitor monitor) {

        String taskName = Messages.AlignmentEditor_SAVING_ALIGNMENT;  //TODO multi language

        monitor.beginTask(taskName, 3);

        //re-loading sequence to avoid session conflicts

        Sequence sequenceNode = CdmStore.getService(ISequenceService.class).load(input.getSequenceNodeUuid());

        input.setSequenceNode(sequenceNode);

        StringAdapter stringProvider = new StringAdapter(getEditableConsensusArea().getAlignmentModel(), false);  // Throws an exception if a token has more than one character.

        // Write consensus sequence:

        SequenceString consensusSequenceObj = sequenceNode.getConsensusSequence();

        String newConsensusSequence = stringProvider.getSequence(

                getEditableConsensusArea().getAlignmentModel().sequenceIDByName(CONSENSUS_NAME));

        if (consensusSequenceObj == null) {

            sequenceNode.setConsensusSequence(SequenceString.NewInstance(newConsensusSequence));

        }

        else {

            consensusSequenceObj.setString(newConsensusSequence);

        }

        // Write single reads:

        stringProvider.setUnderlyingModel(getReadsArea().getAlignmentModel());

        sequenceNode.getSingleReadAlignments().retainAll(cdmMap.values());  // Remove all reads that are not in the alignment anymore.

        Iterator<String> iterator = getReadsArea().getAlignmentModel().sequenceIDIterator();

        while (iterator.hasNext()) {

            String id = iterator.next();

            SingleReadAlignment singleRead = cdmMap.get(id);

            if (singleRead == null) {

                throw new InternalError(Messages.AlignmentEditor_NEW_READ_FAILURE);  //TODO multi language

                //TODO Create new read object. => Shall it be allowed to add reads in the alignment editor which are not represented in the CDM tree before the alignment editor is saved?

                //singleRead = SingleReadAlignment.NewInstance(consensusSequence, singleRead, shifts, editedSequence);

            }

            singleRead.setEditedSequence(stringProvider.getSequence(id));

            PherogramArea pherogramArea = getPherogramArea(id);

            if (pherogramArea != null) {

                PherogramAreaModel model = pherogramArea.getModel();

                singleRead.setReverseComplement(model.getPherogramProvider() instanceof ReverseComplementPherogramProvider);  // Works only if ReverseComplementPherogramProvider instances are not nested.

                singleRead.setShifts(convertToCDMShifts(getPherogramArea(id).getModel()));

                singleRead.setFirstSeqPosition(model.getFirstSeqPos());

                singleRead.setLeftCutPosition(model.getLeftCutPosition());

                singleRead.setRightCutPosition(model.getRightCutPosition());

            }

        }

        if (!conversationHolder.isBound()) {

            conversationHolder.bind();

        }

        monitor.worked(1);

        input.merge();

        // Commit the conversation and start a new transaction immediately:

        conversationHolder.commit(true);

        monitor.worked(1);

        dirty.setDirty(false);

        monitor.worked(1);

        monitor.done();

    }

    public void init(AlignmentEditorInput input) throws PartInitException {

        this.input = input;

        updateStatusBar();

        if (input.getSequenceNodeUuid() != null) {

            Sequence sequenceNode = CdmStore.getService(ISequenceService.class).load(input.getSequenceNodeUuid());

            //re-load into the current session if it is already persisted in the DB

            if(sequenceNode!=null && sequenceNode.getId()!=0){

                sequenceNode = CdmStore.getService(ISequenceService.class).load(sequenceNode.getUuid());

            }

            readCDMData(sequenceNode);

        }

        else {

            createTestContents();  // This case will removed after the test phase and an exception should probably be thrown.

        }

    }

    public boolean isDirty() {

        return dirty.isDirty();

    }

    private void setDirty() {

    	dirty.setDirty(true);

    }

    @Focus

    public void setFocus() {

        if(conversationHolder != null){

            conversationHolder.bind();

        }

        if(input!=null){

            input.bind();

        }

    }

    public boolean isInsertMode() {

        return getAlignmentsContainer().getEditSettings().isInsert();

    }

    public boolean isInsertLeftInPherogram() {

        return getAlignmentsContainer().getEditSettings().isInsertLeftInDataArea();

    }

    public void toggleLeftRightInsertionInPherogram() {

    	getAlignmentsContainer().getEditSettings().toggleInsertLeftInDataArea();

    }

    public void toggleInsertOverwrite() {

    	getAlignmentsContainer().getEditSettings().toggleInsert();

    }

    private String cutPherogram(boolean left) {

        SelectionModel selection = getReadsArea().getSelection();

        if (selection.getCursorHeight() != 1) {

            return Messages.AlignmentEditor_CUTTING_FAILURE;  //TODO multi language

        }

        else {

            PherogramArea pherogramArea =

                    getPherogramArea(getReadsArea().getSequenceOrder().idByIndex(selection.getCursorRow()));

            if (pherogramArea == null) {

                return Messages.AlignmentEditor_NO_ATTACHED_PHEROGRAM;  //TODO multi language

            }

            else {

                if (left) {

                    if (pherogramArea.setLeftCutPositionBySelection()) {

                        return null;

                    }

                    else {

                        return Messages.AlignmentEditor_LEFT_END_OUTSIDE;  //TODO multi language

                    }

                }

                else {

                    if (pherogramArea.setRightCutPositionBySelection()) {

                        return null;

                    }

                    else {

                        return Messages.AlignmentEditor_RIGHT_END_OUTSIDE;  //TODO multi language

                    }

                }

            }

        }

    }

    public String cutPherogramLeft() {

        return cutPherogram(true);

    }

    public String cutPherogramRight() {

        return cutPherogram(false);

    }

    public void reverseComplementSelectedSequences() {

    	SelectionModel selection = getReadsArea().getSelection();

    	AlignmentModel<?> model = getReadsArea().getAlignmentModel();

    	for (int row = selection.getFirstRow(); row < selection.getFirstRow() + selection.getCursorHeight(); row++) {

    		String sequenceID = getReadsArea().getSequenceOrder().idByIndex(row);

			PherogramArea area = getPherogramArea(sequenceID);

			PherogramAreaModel pherogramAlignmentModel = area.getModel();

            PherogramAlignmentRelation rightRelation = pherogramAlignmentModel.editableIndexByBaseCallIndex(

                    pherogramAlignmentModel.getRightCutPosition());

            int rightBorder;

            if (rightRelation.getCorresponding() == PherogramAlignmentRelation.OUT_OF_RANGE) {

                rightBorder = rightRelation.getBeforeValidIndex() + 1;

            }

            else {

                rightBorder = rightRelation.getAfterValidIndex();

            }

			AlignmentModelUtils.reverseComplement(model, sequenceID,

			        pherogramAlignmentModel.editableIndexByBaseCallIndex(

			                pherogramAlignmentModel.getLeftCutPosition()).getBeforeValidIndex(),

			        rightBorder);

			pherogramAlignmentModel.reverseComplement();

		}

    }

    /**

     * Recreates the whole consensus sequence from all single read sequences. The previous consensus

     * sequence is overwritten.

     */

    @SuppressWarnings("unchecked")

    public <T> void createConsensusSequence() {

        ConsensusSequenceArea area = getConsensusHintDataArea();

        AlignmentModel<T> model = (AlignmentModel<T>)getEditableConsensusArea().getAlignmentModel();

        String sequenceID = model.sequenceIDIterator().next();  // There is always one sequence contained.

        int length = getReadsArea().getAlignmentModel().getMaxSequenceLength();

        Collection<T> tokens = new ArrayList<T>(length);

        for (int column = 0; column < length; column++) {

            tokens.add(model.getTokenSet().tokenByRepresentation(area.getConsensusToken(column)));

        }

        model.removeTokensAt(sequenceID, 0, model.getSequenceLength(sequenceID));

        model.insertTokensAt(sequenceID, 0, tokens);

    }

    /**

     * Updates the current consensus sequence by replacing gaps by the according consensus tokens

     * calculated from the single read sequences and extends the consensus sequence if necessary.

     */

    @SuppressWarnings("unchecked")

    public <T> void updateConsensusSequence() {

        ConsensusSequenceArea area = getConsensusHintDataArea();

        AlignmentModel<T> model = (AlignmentModel<T>)getEditableConsensusArea().getAlignmentModel();

        TokenSet<T> tokenSet = model.getTokenSet();

        String sequenceID = model.sequenceIDIterator().next();  // There is always one sequence contained.

        int currentConsensusLength = model.getSequenceLength(sequenceID);

        int overallLength = getReadsArea().getAlignmentModel().getMaxSequenceLength();

        // Replace gaps by new information:

        for (int column = 0; column < currentConsensusLength; column++) {

            if (tokenSet.isGapToken(model.getTokenAt(sequenceID, column))) {

                T newToken = tokenSet.tokenByRepresentation(area.getConsensusToken(column));

                if (!tokenSet.isGapToken(newToken)) {

                    model.setTokenAt(sequenceID, column, newToken);

                }

            }

        }

        // Append additional tokens:

        if (overallLength > currentConsensusLength) {

            Collection<T> tokens = new ArrayList<T>(overallLength);

            for (int column = currentConsensusLength; column < overallLength; column++) {

                tokens.add(tokenSet.tokenByRepresentation(area.getConsensusToken(column)));

            }

            model.appendTokens(sequenceID, tokens);

        }

    }

	public static PherogramProvider readPherogram(URI uri) throws IOException, UnsupportedChromatogramFormatException {

	    PherogramProvider result;

		InputStream stream = uri.toURL().openStream();

		try {

			result = new BioJavaPherogramProvider(ChromatogramFactory.create(stream));

		}

		finally {

			stream.close();

		}

		return result;

	}

	private String newReadName() {

		int index = 1;

		while (getReadsArea().getAlignmentModel().sequenceIDByName(DEFAULT_READ_NAME_PREFIX + index) != null) {

			index++;

		}

		return DEFAULT_READ_NAME_PREFIX + index;

	}

    public void addRead(URI pherogramURI, boolean reverseComplemented) throws IOException, UnsupportedChromatogramFormatException {

    	addRead(newReadName(), pherogramURI, reverseComplemented, null, null, null, null, null);

    }

    /**

     * Adds a new sequence with attached phergram data area to the reads alignment.

     * <p>

     * If {@code null} is specified as {@code editedSequence} the base call sequence from the pherogram will

     * be set as the edited sequence. If {@code null} is specified as {@code shifts} no shifts between the edited

     * and the base calls sequence are assumed.

     *

     * @param name the name of the new sequence

     * @param pherogramURI the URI where the associated pherogram file is located

     * @param reverseComplemented Specify {@code true} here, if the reverse complement of the pherogram data should

     *        be added, {@code false} otherwise.

     * @param editedSequence the edited version of the base call sequence (May be {@code null}.)

     * @param shifts the alignment information that links the edited and the base call sequence (May be {@code null}.)

     * @return the sequence ID of the added read

     * @throws IOException if an error occurred when trying to read the pherogram file

     * @throws UnsupportedChromatogramFormatException if the format of the pherogram file is not supported

     */

    public String addRead(String name, URI pherogramURI, boolean reverseComplemented, String editedSequence,

            Integer firstSeqPos, Integer leftCutPos, Integer rightCutPos, SingleReadAlignment.Shift[] shifts)

            throws IOException, UnsupportedChromatogramFormatException {

		AlignmentModel model = getReadsArea().getAlignmentModel();

		PherogramProvider pherogramProvider = null;

		if (pherogramURI != null) {

		    pherogramProvider = readPherogram(pherogramURI);  // Must happen before a sequence is added, because it might throw an exception.

            if (reverseComplemented) {

                pherogramProvider = new ReverseComplementPherogramProvider(pherogramProvider);

            }

		}

        // Create sequence:

		model.addSequence(name);

		String id = model.sequenceIDByName(name);

		// Set edited sequence:

		Collection<Object> tokens = null;  // First save tokens in a collection to avoid GUI updated for each token.

		if (editedSequence != null) {

			tokens = AlignmentModelUtils.charSequenceToTokenList(editedSequence, model.getTokenSet());

		}

		else if (pherogramProvider != null) {  // Copy base call sequence into alignment:

			tokens = new ArrayList<Object>();

			for (int i = 0; i < pherogramProvider.getSequenceLength(); i++) {

				tokens.add(model.getTokenSet().tokenByRepresentation(

					Character.toString(pherogramProvider.getBaseCall(i))));

			}

			setDirty();

		}

		if (tokens != null) {  // If either an edited sequence or a pherogram URI was provided.

		    model.insertTokensAt(id, 0, tokens);

		    if (pherogramProvider != null) {

		        // Create pherogram area:

		        PherogramArea pherogramArea = new PherogramArea(getReadsArea().getContentArea(),

		                new PherogramAreaModel(pherogramProvider));

		        // Set position properties and shifts:

		        PherogramAreaModel phergramModel = pherogramArea.getModel();

		        if ((firstSeqPos != null) && (leftCutPos != null)) {

		            phergramModel.setFirstSeqLeftCutPos(firstSeqPos, leftCutPos);

		        }

		        if (rightCutPos != null) {

		            phergramModel.setRightCutPosition(rightCutPos);

		        }

		        if ((shifts != null) && (shifts.length > 0)) {

		            for (int i = 0; i < shifts.length; i++) {

		                phergramModel.addShiftChange(shifts[i].position, shifts[i].shift);

		            }

		            setDirty();

		        }

		        // Add pherogram area to GUI:

		        pherogramArea.addMouseListener(new PherogramMouseListener(pherogramArea));

		        getReadsArea().getDataAreas().getSequenceAreas(id).add(pherogramArea);

		    }

		}

		return id;

	}

    public static URI getPherogramURI(SingleRead pherogramInfo) {

        if (pherogramInfo.getPherogram() != null) {

            return MediaUtils.getFirstMediaRepresentationPart(pherogramInfo.getPherogram()).getUri();

        }

        else {

            return null;

        }

    }

}