/*
 * The MIT License (MIT)
 *  Copyright (c) 2007-2015 by Institute for Computational Biomedicine,
 *                                          Weill Medical College of Cornell University.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */


package org.broad.igv.goby;

import com.google.protobuf.ByteString;
import edu.cornell.med.icb.goby.alignments.Alignments;
import edu.cornell.med.icb.goby.alignments.EntryFlagHelper;
import it.unimi.dsi.fastutil.bytes.ByteArrayList;
import it.unimi.dsi.fastutil.bytes.ByteList;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.lang.MutableString;
import org.apache.log4j.Logger;
import org.broad.igv.data.CharArrayList;
import org.broad.igv.feature.LocusScore;
import org.broad.igv.feature.Strand;
import org.broad.igv.prefs.Constants;
import org.broad.igv.prefs.PreferencesManager;
import org.broad.igv.sam.*;
import org.broad.igv.track.WindowFunction;

import java.awt.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

/**
 * A Facade to a <a href="http://goby.campagnelab.org">Goby</a> alignment entry. The facade exposes
 * <a href="http://goby.campagnelab.org">Goby</a> alignment entries in the format expected by
 * IGV. Since <a href="http://goby.campagnelab.org">Goby</a> does not store read sequences,
 * we retrieve the reference sequence on the fly from IGV and transform it to produce the read bases.
 * <p/>
 * For further information about Goby, or to obtain sample alignment files, see http://goby.campagnelab.org
 *
 * @author Fabien Campagne
 *         Date: Jun 29, 2010
 *         Time: 12:07:52 PM
 */
public class GobyAlignment implements Alignment {
    /**
     * Used to log debug and informational messages.
     */
    private static final Logger LOG = Logger.getLogger(GobyAlignment.class);

    protected final Alignments.AlignmentEntry entry;
    private final GobyAlignmentIterator iterator;
    protected AlignmentBlockImpl[] block = new AlignmentBlockImpl[1];
    protected AlignmentBlockImpl[] insertionBlock;
    private CharArrayList gapTypes = null;
    private List<Gap> gaps = null;
    private static final ReadMate unmappedMate = new ReadMate("*", -1, false, true);
    private Comparator<? super AlignmentBlock> blockComparator = new Comparator<AlignmentBlock>() {
        public int compare(AlignmentBlock alignmentBlock, AlignmentBlock alignmentBlock1) {
            return alignmentBlock.getStart() - alignmentBlock1.getStart();
        }
    };

    /**
     * Construct the facade for an iterator and entry.
     *
     * @param iterator Used to retrieve chromosome names from target indices.
     * @param entry    Alignement entry (from Goby protocol buffer Alignment.entries).
     */
    public GobyAlignment(final GobyAlignmentIterator iterator, final Alignments.AlignmentEntry entry) {
        this.iterator = iterator;
        this.entry = entry;
        buildBlocks(entry);
    }


    private boolean hasReadInsertion(String from) {
        return from.length() > 0 && from.charAt(0) == '-';
    }

    /**
     * Construct alignment blocks from the Goby alignment entry. This method uses the convention that '=' denotes a match to the reference.
     * <p/>
     * Conventions for storing sequence variations in Goby alignments are described
     * <a href="http://tinyurl.com/goby-sequence-variations">here</a>
     *
     * @param alignmentEntry The Goby alignment entry to use
     */
    public void buildBlocks(Alignments.AlignmentEntry alignmentEntry) {

        ObjectArrayList<AlignmentBlock> blocks = new ObjectArrayList<AlignmentBlock>();
        ObjectArrayList<AlignmentBlock> insertionBlocks = new ObjectArrayList<AlignmentBlock>();

        int start = alignmentEntry.getPosition();
        ByteArrayList bases = new ByteArrayList();
        ByteArrayList scores = new ByteArrayList();
        int readLength = alignmentEntry.getQueryLength();

        byte[] readBases = new byte[readLength];
        byte[] readQual = new byte[readLength];
        Arrays.fill(readBases, (byte) '=');
        if (alignmentEntry.hasReadQualityScores()) {
            readQual = alignmentEntry.getReadQualityScores().toByteArray();
        } else {
            Arrays.fill(readQual, (byte) 40);
        }
        int j = 0;
        int insertedBases = 0;
        int deletedBases = 0;
        final int leftPadding = alignmentEntry.getQueryPosition();
        boolean showSoftClipped = PreferencesManager.getPreferences().getAsBoolean(Constants.SAM_SHOW_SOFT_CLIPPED);
        if (showSoftClipped && entry.hasSoftClippedBasesLeft()) {
            int clipLength = entry.getSoftClippedBasesLeft().length();

            addSoftClipBlock(blocks, Math.max(0,
                            entry.getPosition() - clipLength),
                    entry.getSoftClippedBasesLeft(), readQual,
                    entry.hasSoftClippedQualityLeft(),
                    entry.getSoftClippedQualityLeft().toByteArray(),
                    0);
        }
        for (Alignments.SequenceVariation var : alignmentEntry.getSequenceVariationsList()) {
            final String from = var.getFrom();
            final int fromLength = from.length();
            final String to = var.getTo();
            final int toLength = from.length();
            final int sequenceVariationLength = Math.max(fromLength, toLength);
            final ByteString toQuality = var.getToQuality();

            if (hasReadInsertion(from)) {
                bases.clear();
                scores.clear();
                for (int i = 0; i < sequenceVariationLength; i++) {
                    final char toChar = i >= toLength ? '-' : to.charAt(i);
                    int size = toQuality.size();
                    final byte qual = size > 0 && i < size ? toQuality.byteAt(i) : 40;

                    bases.add((byte) toChar);
                    scores.add(qual);
                    deletedBases++;

                }
                addBlock(insertionBlocks, alignmentEntry.getPosition() + var.getPosition(), bases, scores);
                bases.clear();
                scores.clear();
            } else if (!to.contains("-")) {
                for (int i = 0; i < toLength; i++) {
                    final int offset = j + var.getPosition() + i - 1 + leftPadding - insertedBases;
                    if (offset > 0 && offset < readBases.length) {
                        readBases[offset] = (byte) to.charAt(i);
                        if (i < toQuality.size()) {
                            readQual[offset] = toQuality.byteAt(i);
                        }
                    }

                }
            } else {
                // has read deletion:
                insertedBases++;
            }
        }


        int pos = start;
        int matchLength = alignmentEntry.getQueryAlignedLength() - deletedBases;
        int endAlignmentRefPosition = matchLength + start;
        bases.clear();
        scores.clear();
        int maxIndex = Math.min(readBases.length, readQual.length);
        while (pos < endAlignmentRefPosition) {
            final int index = pos - start + leftPadding;
            if (index < maxIndex) {
                bases.add(readBases[index]);
                scores.add(readQual[index]);
            } else {
                break;
            }
            ++pos;
        }

        addBlock(blocks, start, bases, scores);
        blocks = introduceDeletions(blocks, entry);
        if (showSoftClipped && entry.hasSoftClippedBasesRight()) {

            int targetAlignedLength = entry.getTargetAlignedLength();
            addSoftClipBlock(blocks, entry.getPosition() + targetAlignedLength,
                    entry.getSoftClippedBasesRight(),
                    readQual,
                    entry.hasSoftClippedQualityRight(),
                    entry.getSoftClippedQualityRight().toByteArray(),
                    entry.getQueryAlignedLength() + entry.getSoftClippedBasesLeft().length());
        }
        block = blocks.toArray(new AlignmentBlockImpl[blocks.size()]);
        Arrays.sort(block, blockComparator);
        insertionBlock = insertionBlocks.toArray(new AlignmentBlockImpl[insertionBlocks.size()]);
        Arrays.sort(insertionBlock, blockComparator);
        ObjectArrayList<GobyAlignment> list = null;

        if (alignmentEntry.hasSplicedForwardAlignmentLink() || alignmentEntry.hasSplicedBackwardAlignmentLink()) {
            // if has a forward link, store a reference to this alignment in the reader (which represents the window scope)
            list = iterator.cacheSpliceComponent(this);
            if (list.size() > 1 && spliceListIsValid(list)) {

                final GobyAlignment spliceHeadAlignment = list.get(0);

                ObjectArrayList<AlignmentBlock> splicedBlocks = new ObjectArrayList<AlignmentBlock>();
                splicedBlocks.addAll(ObjectArrayList.wrap(spliceHeadAlignment.block));
                splicedBlocks.addAll(blocks);
                spliceHeadAlignment.block = splicedBlocks.toArray(new AlignmentBlockImpl[splicedBlocks.size()]);

                ObjectArrayList<AlignmentBlock> splicedInsertionBlocks = new ObjectArrayList<AlignmentBlock>();
                splicedInsertionBlocks.addAll(ObjectArrayList.wrap(spliceHeadAlignment.insertionBlock));
                splicedInsertionBlocks.addAll(insertionBlocks);
                spliceHeadAlignment.insertionBlock = splicedInsertionBlocks.toArray(new AlignmentBlockImpl[splicedInsertionBlocks.size()]);

                if (spliceHeadAlignment.gapTypes == null) {
                    spliceHeadAlignment.gapTypes = new CharArrayList(10);
                }
                spliceHeadAlignment.gapTypes.add(SAMAlignment.SKIPPED_REGION);

                // Since the previous alignment carries this information, we clear up block and insertionBlock
                // in this alignment, but keep any softClips:
                this.block = keepSoftClips(block);
                this.insertionBlock = new AlignmentBlockImpl[0];
            }
        }

        block = removeNulls(block);

    }

    private AlignmentBlockImpl[] removeNulls(AlignmentBlockImpl[] block) {
        int nullCount = 0;
        for (int i = 0; i < block.length; i++) {
            AlignmentBlock alignmentBlock = block[i];
            if (alignmentBlock == null) {
                nullCount++;
            }
        }
        if (nullCount == 0) {
            // nothing to filter
            return block;
        } else {
            int newLength = block.length - nullCount;
            AlignmentBlockImpl[] result = new AlignmentBlockImpl[newLength];
            int j = 0;
            for (int i = 0; i < result.length; i++) {
                result[i] = block[j++];
            }
            return result;
        }
    }

    private AlignmentBlockImpl[] keepSoftClips(AlignmentBlockImpl[] blocks) {
        int numSoftCLippedBlocks = 0;
        for (AlignmentBlock block : blocks) {
            if (block.isSoftClipped()) numSoftCLippedBlocks++;
        }
        AlignmentBlockImpl[] tmp = new AlignmentBlockImpl[numSoftCLippedBlocks];
        int j = 0;
        for (int i = 0; i < numSoftCLippedBlocks; i++) {
            AlignmentBlockImpl block = blocks[j++];
            if (block.isSoftClipped()) {
                tmp[i] = block;
            }
        }
        return tmp;
    }

    private void addSoftClipBlock(ObjectArrayList<AlignmentBlock> blocks, int position, String softClippedBasesLeft,
                                  byte[] readQualScores, boolean hasSoftClippedQuality,
                                  byte[] softClippedQuality, int j) {
        final int length = softClippedBasesLeft.length();
        byte[] bases = new byte[length];
        byte[] scores = new byte[length];

        for (int i = 0; i < length; i++) {
            bases[i] = (byte) softClippedBasesLeft.charAt(i);
            scores[i] = hasSoftClippedQuality ? softClippedQuality[i] : readQualScores[j++];
        }
        final AlignmentBlockImpl alignmentBlock = new AlignmentBlockImpl( position, bases, scores);
        alignmentBlock.setSoftClipped(true);
        blocks.add(alignmentBlock);

    }

    /**
     * Verify that the list has an appropriate unbroken chain of back links.
     *
     * @param list the list of splices to validate
     * @return true if the list has an unbroken chain of back links
     */
    boolean spliceListIsValid(final ObjectArrayList<GobyAlignment> list) {

        if (list != null && list.size() > 1) {
            Alignments.AlignmentEntry prevEntry = list.get(0).entry;
            for (int i = 1; i < list.size(); i++) {
                Alignments.AlignmentEntry currentEntry = list.get(i).entry;
                if (!currentEntry.hasSplicedBackwardAlignmentLink()) return false;
                else {
                    Alignments.RelatedAlignmentEntry currentBackwardLink = currentEntry.getSplicedBackwardAlignmentLink();

                    if ((prevEntry.getQueryIndex() != currentEntry.getQueryIndex()) ||

                            (prevEntry.getFragmentIndex() != currentBackwardLink.getFragmentIndex()) ||
                            (prevEntry.getPosition() != currentBackwardLink.getPosition()) ||
                            (prevEntry.getTargetIndex() != currentBackwardLink.getTargetIndex())) {
                        return false;
                    }
                }
                prevEntry = currentEntry;
            }
        }
        return true;
    }


    /**
     * This method splits blocks whose boundaries contain a read deletion.
     *
     * @param blocks
     * @param alignmentEntry
     * @return
     */
    private ObjectArrayList<AlignmentBlock> introduceDeletions(ObjectArrayList<AlignmentBlock> blocks,
                                                               Alignments.AlignmentEntry alignmentEntry) {

        ObjectArrayList<AlignmentBlock> newBlocks = new ObjectArrayList<AlignmentBlock>();

        for (Alignments.SequenceVariation var : alignmentEntry.getSequenceVariationsList()) {


            for (AlignmentBlock block : blocks) {
                if (!block.isSoftClipped()) {

                    final int vrPos = var.getPosition() + entry.getPosition();
                    if (hasReadDeletion(var) && vrPos >= block.getStart() && vrPos <= block.getEnd()) {

                        ByteList leftBases = new ByteArrayList(block.getBases());
                        ByteList leftScores = new ByteArrayList(block.getQualities());
                        ByteList rightBases = new ByteArrayList(block.getBases());
                        ByteList rightScores = new ByteArrayList(block.getQualities());
                        int deletionPosition = var.getPosition() - 1;
                        leftBases = leftBases.subList(0, deletionPosition);
                        rightBases = rightBases.subList(deletionPosition, rightBases.size());

                        leftScores = leftScores.subList(0, deletionPosition);
                        rightScores = rightScores.subList(deletionPosition, rightScores.size());

                        AlignmentBlock left = new AlignmentBlockImpl(block.getStart(),
                                leftBases.toByteArray(new byte[leftBases.size()]),
                                leftScores.toByteArray(new byte[leftScores.size()]));

                        AlignmentBlock right = new AlignmentBlockImpl(block.getStart() + leftBases.size()
                                + var.getFrom().length(),
                                rightBases.toByteArray(new byte[rightBases.size()]),
                                rightScores.toByteArray(new byte[rightScores.size()]));

                        blocks.remove(block);
                        newBlocks.add(left);
                        newBlocks.add(right);

                    }
                }
            }
        }

        newBlocks.addAll(blocks);
        return newBlocks;
    }

    private boolean hasReadDeletion(Alignments.SequenceVariation var) {
        return (var.getTo().contains("-"));
    }


    private int addBlock(ObjectArrayList<AlignmentBlock> blocks, int start, ByteArrayList bases,
                         ByteArrayList scores) {

        blocks.add(
                new AlignmentBlockImpl(start,
                        bases.toByteArray(new byte[bases.size()]),
                        scores.toByteArray(new byte[scores.size()])));
        start += bases.size();
        bases.clear();
        scores.clear();
        return start;
    }


    /**
     * Transform the read index into a readname:
     *
     * @return
     */
    public String getReadName() {

        return Integer.toString(entry.getQueryIndex());
    }

    public String getReadSequence() {

        return "read-sequence";
    }

    /**
     * Get the reference id from the iterator, prepend "chr".
     */
    public String getChr() {
        return getChromosome(entry.getTargetIndex());
    }

    @Override
    public String getContig() {
        return getChr();
    }

    /**
     * Get the reference id from the iterator, prepend "chr".
     *
     * @param targetIndex Returns the chromosome id
     */
    public String getChromosome(int targetIndex) {
        return "chr" + iterator.getId(targetIndex).toString();
    }

    public int getAlignmentStart() {
        //     //LOG.info("getAlignmentStart");
        return entry.getPosition();
    }

    public boolean contains(double location) {
        return location >= getStart() && location < getEnd();
    }


    public AlignmentBlock[] getAlignmentBlocks() {
        //    //LOG.info("getAlignmentBlocks");

        return block;
    }

    public AlignmentBlock[] getInsertions() {
        //LOG.info("getInsertions");
        return insertionBlock;
    }


    @Override
    public List<Gap> getGaps() {
        if(gaps == null && gapTypes != null && gapTypes.getSize() > 0 && block.length > 1) {
            gaps = new ArrayList<Gap>(gapTypes.getSize());
            char[] types = gapTypes.toArray();

            AlignmentBlock leftBlock = block[0];
            for(int i=1; i<block.length; i++ ) {
                AlignmentBlock rightBlock = block[i];
                int gapStart = leftBlock.getEnd();
                int nBases = rightBlock.getStart() - gapStart;
                char type = types.length <= i ? types[i-1] : 'N';
                if(type == SAMAlignment.SKIPPED_REGION) {
                    gaps.add(new SpliceGap(gapStart, nBases, type, leftBlock.getLength(), rightBlock.getLength()));
                }
                else {
                    gaps.add(new Gap(gapStart, nBases, type));
                }
                leftBlock = rightBlock;
            }
        }

        return gaps;
    }

    public String getCigarString() {
        //LOG.info("getCigarString");
        return null;
    }

    public int getInferredInsertSize() {
        if (entry.hasInsertSize()) {
            return entry.getInsertSize();
        } else return 0;
    }

    public int getMappingQuality() {
        if (entry.hasMappingQuality()) {
            return entry.getMappingQuality();
        } else {

            return 255;
        }
    }

    /**
     * Returns the mate for a paired-end read. Please note that this method will return an unmapped
     * mate for any single end read as well. Do check if the read is paired before calling getMate().
     *
     * @return The mate, or a constant unmapped mate (for single end reads, or paired end where the mate is not found).
     */
    public ReadMate getMate() {
        if (entry.hasPairAlignmentLink()) {
            Alignments.RelatedAlignmentEntry link = entry.getPairAlignmentLink();
            String mateChr = getChromosome(link.getTargetIndex());
            int mateStart = link.getPosition();
            boolean mateNegativeStrand = EntryFlagHelper.isMateReverseStrand(entry);

            boolean isReadUnmappedFlag = EntryFlagHelper.isReadUnmapped(entry);
            final ReadMate mate = new ReadMate(mateChr, mateStart, mateNegativeStrand, isReadUnmappedFlag);
            return mate;
        } else {
            return unmappedMate;
        }
    }

    public boolean isProperPair() {
        if (entry.hasPairFlags()) {

            return EntryFlagHelper.isProperlyPaired(entry);

        } else return false;
    }

    public boolean isMapped() {

        return true;
    }

    public boolean isPaired() {
        if (entry.hasPairFlags()) {

            return EntryFlagHelper.isPaired(entry);

        } else return false;
    }

    public boolean isNegativeStrand() {
        //     //LOG.info("isNegativeStrand");
        return entry.getMatchingReverseStrand();
    }

    public boolean isDuplicate() {
        //LOG.info("isDuplicate");
        return false;
    }

    public int getAlignmentEnd() {
        //LOG.info("getAlignmentEnd");
        return entry.getPosition() + entry.getTargetAlignedLength();
    }


    public String getSample() {
        //LOG.info("getSample");
        return null;
    }

    public String getReadGroup() {
        //LOG.info("getReadGroup");
        return null;
    }

    public String getLibrary() {
        //LOG.info("getReadGroup");
        return null;
    }

    public Object getAttribute(String key) {
        //LOG.info("getAttribute");
        return null;
    }

    /**
     * Return the strand of the read marked "first-in-pair" for a paired alignment. This method can return
     * Strand.NONE if the end marked first is unmapped.
     *
     * @return strand of first-of-pair
     */
    public Strand getFirstOfPairStrand() {
        if (isPaired()) {
            if (isFirstOfPair()) {
                return isNegativeStrand() ? Strand.NEGATIVE : Strand.POSITIVE;
            } else {
                ReadMate mate = getMate();
                if (mate.isMapped() && isProperPair()) {
                    return mate.isNegativeStrand() ? Strand.NEGATIVE : Strand.POSITIVE;
                } else {
                    return Strand.NONE;
                }
            }

        } else {
            return isNegativeStrand() ? Strand.NEGATIVE : Strand.POSITIVE;
        }
    }

    /**
     * Return the strand of the read marked "second-in-pair" for a paired alignment.  The strand is
     * undefined (Strand.NONE) for non-paired alignments
     *
     * @return strand of second-of-pair
     */
    public Strand getSecondOfPairStrand() {
        if (isPaired()) {
            if (isSecondOfPair()) {
                return isNegativeStrand() ? Strand.NEGATIVE : Strand.POSITIVE;
            } else {
                ReadMate mate = getMate();
                if (mate.isMapped() && isProperPair()) {
                    return mate.isNegativeStrand() ? Strand.NEGATIVE : Strand.POSITIVE;
                } else {
                    return Strand.NONE;
                }
            }

        } else {
            // Undefined for non-paired alignments
            return Strand.NONE;
        }
    }

    public void setMateSequence(String sequence) {
        //LOG.info("setMateSequence");

    }

    public String getPairOrientation() {
        //LOG.info("getPairOrientation");
        String pairOrientation = "";
        if (EntryFlagHelper.isPaired(entry) &&

                !EntryFlagHelper.isMateUnmapped(entry) &&
                entry.getTargetIndex() == entry.getPairAlignmentLink().getTargetIndex()) {

            char s1 = EntryFlagHelper.isReadReverseStrand(entry) ? 'R' : 'F';
            char s2 = EntryFlagHelper.isMateReverseStrand(entry) ? 'R' : 'F';
            char o1 = ' ';
            char o2 = ' ';
            char[] tmp = new char[4];
            if (EntryFlagHelper.isFirstInPair(entry)) {
                o1 = '1';
                o2 = '2';
            } else if (EntryFlagHelper.isSecondInPair(entry)) {
                o1 = '2';
                o2 = '1';
            }
            if (getInferredInsertSize() > 0) {
                tmp[0] = s1;
                tmp[1] = o1;
                tmp[2] = s2;
                tmp[3] = o2;

            } else {
                tmp[2] = s1;
                tmp[3] = o1;
                tmp[0] = s2;
                tmp[1] = o2;
            }
            pairOrientation = new String(tmp);
        }
        return pairOrientation;
    }

    public boolean isSmallInsert() {
        //LOG.info("isSmallInsert");
        return false;
    }


    /**
     * Return true if this read failed vendor quality checks
     */
    public boolean isVendorFailedRead() {
        return false;
    }

    /**
     * Return the default color with which to render this alignment
     *
     * @return
     */
    public Color getYcColor() {
        return null;
    }

    public int getStart() {
        //      //LOG.info("getStart");
        return entry.getPosition();
    }

    public int getEnd() {
        //    //LOG.info("getEnd");
        if (block.length == 0) return getStart();
        else {

            int last = block.length - 1;
            if (block[last] == null) {
                // System.out.println("STOP");
                return entry.getPosition() + entry.getTargetAlignedLength();
            }
            return block[last].getEnd();
        }
    }

    public void setStart(
            int start) {
        //    //LOG.info("setStart");
        throw new UnsupportedOperationException("setStart is not supported");
        //To change body of implemented methods use File | Settings | File Templates.
    }

    public void setEnd(
            int end) {
        throw new UnsupportedOperationException("setEnd is not supported");
        //To change body of implemented methods use File | Settings | File Templates.
    }

    public float getScore() {
        //LOG.info("getScore");
        return entry.getScore();
    }


    public LocusScore copy() {
        return this;
    }


    /**
     * This method is provide to provide as a hook for customizing the text that is copied to the clipboard.
     * The default behavior is to just copy the tooltip text.
     *
     * @param location
     * @param mouseX
     * @return
     */
    public String getClipboardString(double location, int mouseX) {
        return getValueString(location, mouseX, null);
    }


    public String getValueString(double position, int mouseX, WindowFunction windowFunction) {
        //  //LOG.info("getValueString");
        MutableString buffer = new MutableString();

        buffer.append(entry.toString());
        buffer.replace("\n", "<br>");

        if (this.isPaired()) {
            buffer.append("----------------------" + "<br>");
            buffer.append("Mate start = " + getMate().positionString() + "<br>");
            buffer.append("Mate is mapped = " + (getMate().isMapped() ? "yes" : "no") + "<br>");
            //buf.append("Pair is proper = " + (getProperPairFlag() ? "yes" : "no") + "<br>");
            if (getChr().equals(getMate().getChr())) {
                buffer.append("Insert size = " + getInferredInsertSize() + "<br>");
            }
            if (getPairOrientation().length() > 0) {
                buffer.append("Pair orientation = " + getPairOrientation() + "<br>");
            }
            if (isFirstOfPair()) {
                buffer.append("First of pair <br>");
            }
            if (isSecondOfPair()) {
                buffer.append("Second of pair <br>");
            }
        }
        return buffer.toString();
    }

    public byte getBase(double position) {
        int basePosition = (int) position;
        for (AlignmentBlock block : getAlignmentBlocks()) {
            if (block.contains(basePosition)) {
                int offset = basePosition - block.getStart();
                byte base = block.getBase(offset);
                return base;
            }
        }
        return 0;
    }

    public byte getPhred(double position) {
        int basePosition = (int) position;
        for (AlignmentBlock block : getAlignmentBlocks()) {
            if (block.contains(basePosition)) {
                int offset = basePosition - block.getStart();
                byte score = block.getQuality(offset);
                return score;
            }
        }
        return 0;
    }


    /**
     * Return true if this alignment is marked "first in pair".  Added to suppor bisulfite sequencing mode.
     */
    public boolean isFirstOfPair() {
        return EntryFlagHelper.isFirstInPair(entry);
    }


    /**
     * Return true if this alignment is marked "second in pair".  Added to suppor bisulfite sequencing mode.
     */
    public boolean isSecondOfPair() {
        return EntryFlagHelper.isSecondInPair(entry);
    }

    public Strand getReadStrand() {
        return isNegativeStrand() ? Strand.NEGATIVE : Strand.POSITIVE;
    }

    @Override
    public void finish() {
    }

    @Override
    public boolean isPrimary() {
        return !EntryFlagHelper.isNotPrimaryAlignment(entry);
    }

    @Override
    public boolean isSupplementary() {
        // The SAM 0x0800 tag
        return false;
    }
}
