* Copyright (c) 2007-2012 The Broad Institute, Inc.

* SOFTWARE COPYRIGHT NOTICE

* This software and its documentation are the copyright of the Broad Institute, Inc. All rights are reserved.

*

* This software is supplied without any warranty or guaranteed support whatsoever. The Broad Institute is not responsible for its use, misuse, or functionality.

*

* This software is licensed under the terms of the GNU Lesser General Public License (LGPL),

* Version 2.1 which is available at http://www.opensource.org/licenses/lgpl-2.1.php.

*/

* @author jrobinso

*/

    private static Logger log = Logger.getLogger(AlignmentTrack.class);

    static final int GROUP_MARGIN = 5;

    static final int TOP_MARGIN = 20;

    static final int DS_MARGIN_0 = 2;

    static final int DOWNAMPLED_ROW_HEIGHT = 3;

    static final int DS_MARGIN_2 = 5;

    private boolean showSpliceJunctions;

    public enum ShadeBasesOption {

        NONE, QUALITY, FLOW_SIGNAL_DEVIATION_READ, FLOW_SIGNAL_DEVIATION_REFERENCE

    }

    public enum ExperimentType {

        RNA, BISULFITE, OTHER

    }

    public enum ColorOption {

        INSERT_SIZE, READ_STRAND, FIRST_OF_PAIR_STRAND, PAIR_ORIENTATION, SAMPLE, READ_GROUP, BISULFITE, NOMESEQ,

        TAG, NONE, UNEXPECTED_PAIR

    }

    public enum SortOption {

        START, STRAND, NUCLEOTIDE, QUALITY, SAMPLE, READ_GROUP, INSERT_SIZE, FIRST_OF_PAIR_STRAND, MATE_CHR, TAG, SUPPLEMENTARY, NONE;

    }

    public enum GroupOption {

        STRAND, SAMPLE, READ_GROUP, FIRST_OF_PAIR_STRAND, TAG, PAIR_ORIENTATION, MATE_CHROMOSOME, NONE, SUPPLEMENTARY

    }

    public enum BisulfiteContext {

        CG, CHH, CHG, HCG, GCH, WCG

    }

    enum OrientationType {

        RR, LL, RL, LR, UNKNOWN

    }

    protected static final Map<BisulfiteContext, String> bisulfiteContextToPubString = new HashMap<BisulfiteContext, String>();

    static {

        bisulfiteContextToPubString.put(BisulfiteContext.CG, "CG");

        bisulfiteContextToPubString.put(BisulfiteContext.CHH, "CHH");

        bisulfiteContextToPubString.put(BisulfiteContext.CHG, "CHG");

        bisulfiteContextToPubString.put(BisulfiteContext.HCG, "HCG");

        bisulfiteContextToPubString.put(BisulfiteContext.GCH, "GCH");

        bisulfiteContextToPubString.put(BisulfiteContext.WCG, "WCG");

    }

    protected static final Map<BisulfiteContext, Pair<byte[], byte[]>> bisulfiteContextToContextString = new HashMap<BisulfiteContext, Pair<byte[], byte[]>>();

    static {

        bisulfiteContextToContextString.put(BisulfiteContext.CG, new Pair<byte[], byte[]>(new byte[]{}, new byte[]{'G'}));

        bisulfiteContextToContextString.put(BisulfiteContext.CHH, new Pair<byte[], byte[]>(new byte[]{}, new byte[]{'H', 'H'}));

        bisulfiteContextToContextString.put(BisulfiteContext.CHG, new Pair<byte[], byte[]>(new byte[]{}, new byte[]{'H', 'G'}));

        bisulfiteContextToContextString.put(BisulfiteContext.HCG, new Pair<byte[], byte[]>(new byte[]{'H'}, new byte[]{'G'}));

        bisulfiteContextToContextString.put(BisulfiteContext.GCH, new Pair<byte[], byte[]>(new byte[]{'G'}, new byte[]{'H'}));

        bisulfiteContextToContextString.put(BisulfiteContext.WCG, new Pair<byte[], byte[]>(new byte[]{'W'}, new byte[]{'G'}));

    }

    static final ShadeBasesOption DEFAULT_SHADE_BASES_OPTION = ShadeBasesOption.QUALITY;

    static final ColorOption DEFAULT_COLOR_OPTION = ColorOption.INSERT_SIZE;

    static final boolean DEFAULT_SHOWALLBASES = false;

    static final BisulfiteContext DEFAULT_BISULFITE_CONTEXT = BisulfiteContext.CG;

    private boolean ionTorrent;

    private SequenceTrack sequenceTrack;

    private CoverageTrack coverageTrack;

    private SpliceJunctionFinderTrack spliceJunctionTrack;

    private RenderOptions renderOptions = new RenderOptions();

    private int expandedHeight = 14;

    private int maxSquishedHeight = 4;

    private int squishedHeight = maxSquishedHeight;

    private FeatureRenderer renderer;

    private double minVisibleScale = 25;

    private HashMap<String, Color> selectedReadNames = new HashMap();

    private int selectionColorIndex = 0;

    private int minHeight = 50;

    private AlignmentDataManager dataManager;

    private Genome genome;

    // The "parent" of the track (a DataPanel).  This field might be null at any given time.  It is updated each repaint.

    JComponent parent;

    private Rectangle alignmentsRect;

    private Rectangle downsampleRect;

    private ColorTable readNamePalette;

    /**

     * Create a new alignment track

     *

     * @param locator

     * @param dataManager

     * @param genome

     */

    public AlignmentTrack(ResourceLocator locator, AlignmentDataManager dataManager, Genome genome) {

        super(locator);

        this.genome = genome;

        this.dataManager = dataManager;

        ionTorrent = dataManager.isIonTorrent();

        minimumHeight = 50;

        maximumHeight = Integer.MAX_VALUE;

        PreferenceManager prefs = PreferenceManager.getInstance();

        setShowSpliceJunctions(prefs.getAsBoolean(PreferenceManager.SAM_SHOW_JUNCTION_TRACK));

        float maxRange = prefs.getAsFloat(PreferenceManager.SAM_MAX_VISIBLE_RANGE);

        minVisibleScale = (maxRange * 1000) / 700;

        renderer = AlignmentRenderer.getInstance();

        this.setDisplayMode(DisplayMode.EXPANDED);

        if (prefs.getAsBoolean(PreferenceManager.SAM_SHOW_REF_SEQ)) {

            sequenceTrack = new SequenceTrack("Reference sequence");

            sequenceTrack.setHeight(14);

        }

        if (renderOptions.getColorOption() == ColorOption.BISULFITE) {

            setExperimentType(ExperimentType.BISULFITE);

        }

        readNamePalette = new PaletteColorTable(ColorUtilities.getDefaultPalette());

        // Register track

        if (!Globals.isHeadless()) {

            IGV.getInstance().addAlignmentTrackEventListener(this);

        }

    }

    /**

     * Set the experiment type (RNA, Bisulfite, or OTHER)

     *

     * @param type

     */

    public void setExperimentType(ExperimentType type) {

        dataManager.setExperimentType(type);

        if (spliceJunctionTrack != null) {

            spliceJunctionTrack.setVisible(type != ExperimentType.BISULFITE);

        }

    }

    public void setCoverageTrack(CoverageTrack coverageTrack) {

        this.coverageTrack = coverageTrack;

        this.coverageTrack.setRenderOptions(this.renderOptions);

    }

    @XmlElement(name = RenderOptions.NAME)

    private void setRenderOptions(RenderOptions renderOptions) {

        this.renderOptions = renderOptions;

        if (this.coverageTrack != null) {

            this.coverageTrack.setRenderOptions(this.renderOptions);

        }

    }

    @SubtlyImportant

    private RenderOptions getRenderOptions() {

        return this.renderOptions;

    }

    public CoverageTrack getCoverageTrack() {

        return coverageTrack;

    }

    public void setSpliceJunctionTrack(SpliceJunctionFinderTrack spliceJunctionTrack) {

        this.spliceJunctionTrack = spliceJunctionTrack;

        if (dataManager.getExperimentType() == ExperimentType.BISULFITE) {

            spliceJunctionTrack.setVisible(false);

        }

    }

    @Override

    public IGVPopupMenu getPopupMenu(TrackClickEvent te) {

        return new PopupMenu(te);

    }

    @Override

    public void setHeight(int preferredHeight) {

        super.setHeight(preferredHeight);

        minimumHeight = preferredHeight;

    }

    @Override

    public int getHeight() {

        if (parent != null

                && (parent instanceof DataPanel && ((DataPanel) parent).getFrame().getScale() > minVisibleScale)) {

            return minimumHeight;

        }

        int nGroups = dataManager.getMaxGroupCount();

        int h = Math.max(minHeight, getNLevels() * getRowHeight() + nGroups * GROUP_MARGIN + TOP_MARGIN

                + DS_MARGIN_0 + DOWNAMPLED_ROW_HEIGHT + DS_MARGIN_2);

        h = Math.min(maximumHeight, h);

        return h;

    }

    private int getRowHeight() {

        return getDisplayMode() == DisplayMode.EXPANDED ? expandedHeight : squishedHeight;

    }

    private int getNLevels() {

        return dataManager.getNLevels();

    }

    @Override

    public void load(RenderContext context) {

        dataManager.load(context, renderOptions, true);

    }

    public void render(RenderContext context, Rectangle rect) {

        parent = context.getPanel();

        // Split track rectangle into sections.

        int seqHeight = sequenceTrack == null ? 0 : sequenceTrack.getHeight();

        if (seqHeight > 0) {

            Rectangle seqRect = new Rectangle(rect);

            seqRect.height = seqHeight;

            sequenceTrack.render(context, seqRect);

        }

        // Top gap.

        rect.y += DS_MARGIN_0;

        if (context.getScale() > minVisibleScale) {

            Rectangle visibleRect = context.getVisibleRect().intersection(rect);

            Graphics2D g = context.getGraphic2DForColor(Color.gray);

            GraphicUtils.drawCenteredText("Zoom in to see alignments.", visibleRect, g);

            return;

        }

        downsampleRect = new Rectangle(rect);

        downsampleRect.height = DOWNAMPLED_ROW_HEIGHT;

        renderDownsampledIntervals(context, downsampleRect);

        alignmentsRect = new Rectangle(rect);

        alignmentsRect.y += DOWNAMPLED_ROW_HEIGHT + DS_MARGIN_2;

        renderAlignments(context, alignmentsRect);

    }

    private void renderDownsampledIntervals(RenderContext context, Rectangle downsampleRect) {

        // Might be offscreen

        if (!context.getVisibleRect().intersects(downsampleRect)) return;

        final AlignmentInterval loadedInterval = dataManager.getLoadedInterval(context.getReferenceFrame().getCurrentRange());

        if (loadedInterval == null) return;

        Graphics2D g = context.getGraphic2DForColor(Color.black);

        List<DownsampledInterval> intervals = loadedInterval.getDownsampledIntervals();

        for (DownsampledInterval interval : intervals) {

            int x0 = context.bpToScreenPixel(interval.getStart());

            int x1 = context.bpToScreenPixel(interval.getEnd());

            int w = Math.max(1, x1 - x0);

            // If there is room, leave a gap on one side

            if (w > 5) w--;

            // Greyscale from 0 -> 100 downsampled

            //int gray = 200 - interval.getCount();

            //Color color = (gray <= 0 ? Color.black : ColorUtilities.getGrayscaleColor(gray));

            g.fillRect(x0, downsampleRect.y, w, downsampleRect.height);

        }

    }

    private void renderAlignments(RenderContext context, Rectangle inputRect) {

        //log.debug("Render features");

        PackedAlignments groups = dataManager.getGroups(context, renderOptions);

        if (groups == null) {

            //Assume we are still loading.

            //This might not always be true

            return;

        }

        Map<String, PEStats> peStats = dataManager.getPEStats();

        if (peStats != null) {

            renderOptions.peStats = peStats;

        }

        Rectangle visibleRect = context.getVisibleRect();

        final boolean leaveMargin = getDisplayMode() == DisplayMode.EXPANDED;

        if (renderOptions.isPairedArcView()) {

            maximumHeight = (int) inputRect.getHeight();

            AlignmentRenderer.getInstance().clearCurveMaps();

        } else {

            maximumHeight = Integer.MAX_VALUE;

        }

        // Divide rectangle into equal height levels

        double y = inputRect.getY();

        double h = expandedHeight;

        if (getDisplayMode() != DisplayMode.EXPANDED) {

            int visHeight = visibleRect.height;

            int depth = dataManager.getNLevels();

            if (depth == 0) {

                squishedHeight = Math.min(maxSquishedHeight, Math.max(1, expandedHeight));

            } else {

                squishedHeight = Math.min(maxSquishedHeight, Math.max(1, Math.min(expandedHeight, visHeight / depth)));

            }

            h = squishedHeight;

        }

        // Loop through groups

        Graphics2D groupBorderGraphics = context.getGraphic2DForColor(AlignmentRenderer.GROUP_DIVIDER_COLOR);

        int nGroups = groups.size();

        int groupNumber = 0;

        for (Map.Entry<String, List<Row>> entry : groups.entrySet()) {

            groupNumber++;

            // Loop through the alignment rows for this group

            List<Row> rows = entry.getValue();

            for (Row row : rows) {

                if ((visibleRect != null && y > visibleRect.getMaxY())) {

                    return;

                }

                if (renderOptions.isPairedArcView()) {

                    y = Math.min(getY() + getHeight(), visibleRect.getMaxY());

                    y -= h;

                }

                if (y + h > visibleRect.getY()) {

                    Rectangle rowRectangle = new Rectangle(inputRect.x, (int) y, inputRect.width, (int) h);

                    renderer.renderAlignments(row.alignments, context, rowRectangle,

                            inputRect, renderOptions, leaveMargin, selectedReadNames);

                }

                y += h;

            }

            // Draw a subtle divider line between groups

            if (groupNumber < nGroups) {

                int borderY = (int) y + GROUP_MARGIN / 2;

                groupBorderGraphics.drawLine(inputRect.x, borderY, inputRect.width, borderY);

            }

            y += GROUP_MARGIN;

        }

        final int bottom = inputRect.y + inputRect.height;

        groupBorderGraphics.drawLine(inputRect.x, bottom, inputRect.width, bottom);

    }

    /**

     * Sort alignment rows based on alignments that intersect location

     *

     * @return Whether sorting was performed. If data is still loading, this will return false

     */

    public boolean sortRows(SortOption option, ReferenceFrame referenceFrame, double location, String tag) {

        return dataManager.sortRows(option, referenceFrame, location, tag);

    }

    /**

     * Visually regroup alignments by the provided {@code GroupOption}.

     *

     * @param option

     * @param referenceFrames

     * @see AlignmentDataManager#packAlignments

     */

    public void groupAlignments(GroupOption option, List<ReferenceFrame> referenceFrames) {

        if (renderOptions.groupByOption != option) {

            renderOptions.groupByOption = (option == GroupOption.NONE ? null : option);

            dataManager.packAlignments(renderOptions);

        }

    }

    public void packAlignments() {

        dataManager.packAlignments(renderOptions);

    }

    /**

     * Copy the contents of the popup text to the system clipboard.

     */

    public void copyToClipboard(final TrackClickEvent e, Alignment alignment, double location) {

        if (alignment != null) {

            StringBuffer buf = new StringBuffer();

            buf.append(alignment.getValueString(location, null).replace("<br>", "\n"));

            buf.append("\n");

            buf.append("Alignment start position = " + alignment.getChr() + ":" + (alignment.getAlignmentStart() + 1));

            buf.append("\n");

            buf.append(alignment.getReadSequence());

            StringSelection stringSelection = new StringSelection(buf.toString());

            Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();

            clipboard.setContents(stringSelection, null);

        }

    }

    /**

     * Copy the contents of the popup text to the system clipboard.

     */

    public void copyFlowSignalDistribution(final TrackClickEvent e, int location) {

        ArrayList<FlowDistribution> dists = getFlowSignalDistribution(e.getFrame(), location);

        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();

        String json = "";

        for (FlowDistribution dist : dists) {

            json += dist.toJson() + "\n";

        }

        clipboard.setContents(new StringSelection(json), null);

    }

    /**

     * by default, returns both for forward and backward strand

     */

    private ArrayList<FlowDistribution> getFlowSignalDistribution(ReferenceFrame frame, int location) {

        return getFlowSignalDistribution(frame, location, true, true);

    }

    private ArrayList<FlowDistribution> getFlowSignalDistribution(ReferenceFrame frame, int location, boolean forward, boolean reverse) {

        // one for each base!

        ArrayList<TreeMap<Short, Integer>> alleletrees = new ArrayList<TreeMap<Short, Integer>>();

        int nrflows = 0;

        ArrayList<FlowDistribution> alleledist = new ArrayList<FlowDistribution>();

        String bases = "";

        // also store information on read and position

        ArrayList<ArrayList<ReadInfo>> allelereadinfos = new ArrayList<ArrayList<ReadInfo>>();

        AlignmentInterval interval = dataManager.getLoadedInterval(frame.getCurrentRange());

        Iterator<Alignment> alignmentIterator = interval.getAlignmentIterator();

        while (alignmentIterator.hasNext()) {

            Alignment alignment = alignmentIterator.next();

            if ((alignment.isNegativeStrand() && !reverse) || (!alignment.isNegativeStrand() && !forward)) {

                continue;

            }

            if (!alignment.contains(location)) {

                continue;

            }

            // we don't want the beginning or the end of the alignment! HP might might give misleading results

            if (alignment.getAlignmentStart() == location || alignment.getAlignmentEnd() == location) {

                log.info(location + " for read " + alignment.getReadName() + " is at an end, not taking it");

                continue;

            }

            // also throw away positions near the end if we have the same base until the end if the user preference is set that way

            boolean hideFirstHPs = PreferenceManager.getInstance().getAsBoolean(PreferenceManager.IONTORRENT_FLOWDIST_HIDE_FIRST_HP);

            if (hideFirstHPs) {

                char baseatpos = (char) alignment.getBase(location);

                boolean hp = true;

                for (int pos = alignment.getAlignmentStart(); pos < location; pos++) {

                    if ((char) alignment.getBase(pos) != baseatpos) {

                        hp = false;

                        break;

                    }

                }

                if (hp) {

                    log.info("Got all same bases " + baseatpos + " for read " + alignment.getReadName() + " at START.");

                    continue;

                }

                hp = true;

                for (int pos = location + 1; pos < alignment.getAlignmentEnd(); pos++) {

                    if ((char) alignment.getBase(pos) != baseatpos) {

                        hp = false;

                        break;

                    }

                }

                if (hp) {

                    log.info("Got all same bases " + baseatpos + " for read " + alignment.getReadName() + " at END");

                    continue;

                }

            }

            AlignmentBlock[] blocks = alignment.getAlignmentBlocks();

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

                AlignmentBlock block = blocks[i];

                int posinblock = (int) location - block.getStart();

                if (!block.contains((int) location) || !block.hasFlowSignals()) {

                    continue;

                }

                int flownr = block.getFlowSignalSubContext(posinblock).getFlowOrderIndex();

                nrflows++;

                short flowSignal = block.getFlowSignalSubContext(posinblock).getCurrentSignal();

                char base = (char) block.getBase(posinblock);

                int whichbase = bases.indexOf(base);

                TreeMap<Short, Integer> map = null;

                ArrayList<ReadInfo> readinfos = null;

                if (whichbase < 0) {

                    bases += base;

                    map = new TreeMap<Short, Integer>();

                    alleletrees.add(map);

                    readinfos = new ArrayList<ReadInfo>();

                    allelereadinfos.add(readinfos);

                } else {

                    map = alleletrees.get(whichbase);

                    readinfos = allelereadinfos.get(whichbase);

                }

                ReadInfo readinfo = new ReadInfo(alignment.getReadName(), flownr, flowSignal, base);

                readinfos.add(readinfo);

                if (map.containsKey(flowSignal)) {

                    // increment

                    map.put(flowSignal, map.get(flowSignal) + 1);

                } else {

                    // insert

                    map.put(flowSignal, 1);

                }

            }

        }

        String locus = Locus.getFormattedLocusString(frame.getChrName(), (int) location, (int) location);

        int which = 0;

        for (TreeMap<Short, Integer> map : alleletrees) {

            String name = "";

            if (forward && reverse) {

                name += "both strand";

            } else if (forward) {

                name += "forward strand";

            } else {

                name += "reverse strand";

            }

            char base = bases.charAt(which);

            name += ", " + base + ", " + nrflows + " flows";

            String info = locus + ", " + bases;

            FlowDistribution dist = new FlowDistribution(location, nrflows, map, name, base, forward, reverse, info);

            dist.setReadInfos(allelereadinfos.get(which));

            alleledist.add(dist);

            which++;

        }

        return alleledist;

    }

    /**

     * Jump to the mate region

     */

    public void gotoMate(final TrackClickEvent te, Alignment alignment) {

        if (alignment != null) {

            ReadMate mate = alignment.getMate();

            if (mate != null && mate.isMapped()) {

                setSelected(alignment);

                String chr = mate.getChr();

                int start = mate.start - 1;

                // Don't change scale

                double range = te.getFrame().getEnd() - te.getFrame().getOrigin();

                int newStart = (int) Math.max(0, (start + (alignment.getEnd() - alignment.getStart()) / 2 - range / 2));

                int newEnd = newStart + (int) range;

                te.getFrame().jumpTo(chr, newStart, newEnd);

                te.getFrame().recordHistory();

            } else {

                MessageUtils.showMessage("Alignment does not have mate, or it is not mapped.");

            }

        }

    }

    /**

     * Split the screen so the current view and mate region are side by side.

     * Need a better name for this method.

     */

    public void splitScreenMate(final TrackClickEvent te, Alignment alignment) {

        if (alignment != null) {

            ReadMate mate = alignment.getMate();

            if (mate != null && mate.isMapped()) {

                setSelected(alignment);

                String mateChr = mate.getChr();

                int mateStart = mate.start - 1;

                ReferenceFrame frame = te.getFrame();

                String locus1 = frame.getFormattedLocusString();

                // Generate a locus string for the read mate.  Keep the window width (in base pairs) == to the current range

                Range range = frame.getCurrentRange();

                int length = range.getLength();

                int s2 = Math.max(0, mateStart - length / 2);

                int e2 = s2 + length;

                String startStr = NumberFormat.getInstance().format(s2);

                String endStr = NumberFormat.getInstance().format(e2);

                String mateLocus = mateChr + ":" + startStr + "-" + endStr;

                Session currentSession = IGV.getInstance().getSession();

                List<String> loci = null;

                if (FrameManager.isGeneListMode()) {

                    loci = new ArrayList<String>(FrameManager.getFrames().size());

                    for (ReferenceFrame ref : FrameManager.getFrames()) {

                        //If the frame-name is a locus, we use it unaltered

                        //Don't want to reprocess, easy to get off-by-one

                        String name = ref.getName();

                        if (Locus.fromString(name) != null) {

                            loci.add(name);

                        } else {

                            loci.add(ref.getFormattedLocusString());

                        }

                    }

                    loci.add(mateLocus);

                } else {

                    loci = Arrays.asList(locus1, mateLocus);

                }

                StringBuffer listName = new StringBuffer();

                for (String s : loci) {

                    listName.append(s + "   ");

                }

                GeneList geneList = new GeneList(listName.toString(), loci, false);

                currentSession.setCurrentGeneList(geneList);

                Comparator<String> geneListComparator = new Comparator<String>() {

                    @Override

                    public int compare(String n0, String n1) {

                        ReferenceFrame f0 = FrameManager.getFrame(n0);

                        ReferenceFrame f1 = FrameManager.getFrame(n1);

                        int chrComp = ChromosomeNameComparator.get().compare(f0.getChrName(), f1.getChrName());

                        if (chrComp != 0) return chrComp;

                        return f0.getCurrentRange().getStart() - f1.getCurrentRange().getStart();

                    }

                };

                //Need to sort the frames by position

                currentSession.sortGeneList(geneListComparator);

                IGV.getInstance().resetFrames();

            } else {

                MessageUtils.showMessage("Alignment does not have mate, or it is not mapped.");

            }

        }

    }

    public boolean isLogNormalized() {

        return false;

    }

    public float getRegionScore(String chr, int start, int end, int zoom, RegionScoreType type, String frameName) {

        return 0.0f;

    }

    public AlignmentDataManager getDataManager() {

        return dataManager;

    }

    //Public only for testing

    @XmlAttribute

    public boolean isShowSpliceJunctions() {

        return showSpliceJunctions;

    }

    @SubtlyImportant

    private void setShowSpliceJunctions(boolean showSpliceJunctions) {

        this.showSpliceJunctions = showSpliceJunctions;

    }

    public String getValueStringAt(String chr, double position, int y, ReferenceFrame frame) {

        if (downsampleRect != null && y > downsampleRect.y && y <= downsampleRect.y + downsampleRect.height) {

            AlignmentInterval loadedInterval = dataManager.getLoadedInterval(frame.getCurrentRange());

            if (loadedInterval == null) {

                return null;

            } else {

                List<DownsampledInterval> intervals = loadedInterval.getDownsampledIntervals();

                DownsampledInterval interval = (DownsampledInterval) FeatureUtils.getFeatureAt(position, 0, intervals);

                if (interval != null) {

                    return interval.getValueString();

                }

                return null;

            }

        } else if (renderOptions.isPairedArcView()) {

            Alignment feature = null;

            //All alignments stacked at the bottom

            double xloc = (position - frame.getOrigin()) / frame.getScale();

            SortedSet<Shape> arcs = AlignmentRenderer.getInstance().curveOverlap(xloc);

            int halfLength = 2;

            int sideLength = 2 * halfLength;

            for (Shape curve : arcs) {

                if (curve.intersects(xloc - halfLength, y - halfLength, sideLength, sideLength)) {

                    feature = AlignmentRenderer.getInstance().getAlignmentForCurve(curve);

                    break;

                }

            }

            return feature == null ? null : feature.getValueString(position, getWindowFunction());

        } else {

            Alignment feature = getAlignmentAt(position, y, frame);

            return feature == null ? null : feature.getValueString(position, getWindowFunction());

        }

    }

    private Alignment getAlignment(final TrackClickEvent te) {

        MouseEvent e = te.getMouseEvent();

        final ReferenceFrame frame = te.getFrame();

        if (frame == null) {

            return null;

        }

        final double location = frame.getChromosomePosition(e.getX());

        return getAlignmentAt(location, e.getY(), frame);

    }

    private Alignment getAlignmentAt(double position, int y, ReferenceFrame frame) {

        if (alignmentsRect == null) {

            return null;   // <= not loaded yet

        }

        PackedAlignments groups = dataManager.getGroupedAlignmentsContaining(position, frame);

        if (groups == null || groups.isEmpty()) {

            return null;

        }

        int h = getDisplayMode() == DisplayMode.EXPANDED ? expandedHeight : squishedHeight;

//        if (levelNumber < 0) {

//            return null;

//        }

        int startY = alignmentsRect.y;

        final boolean leaveMargin = getDisplayMode() == DisplayMode.EXPANDED;

        for (List<Row> rows : groups.values()) {

            int endY = startY + rows.size() * h;

            if (y >= startY && y < endY) {

                int levelNumber = (y - startY) / h;

                Row row = rows.get(levelNumber);

                List<Alignment> features = row.alignments;

                // No buffer for alignments,  you must zoom in far enough for them to be visible

                int buffer = 0;

                return (Alignment) FeatureUtils.getFeatureAt(position, buffer, features);

            }

            startY = endY + GROUP_MARGIN;

        }

        return null;

    }

    /**

     * Handle an AlignmentTrackEvent.

     *

     * @param e

     */

    public void onAlignmentTrackEvent(AlignmentTrackEvent e) {

        AlignmentTrackEvent.Type type = e.getType();

        switch (type) {

            case VISIBILITY_WINDOW:

                visibilityWindowChanged();

                break;

            case RELOAD:

            case SPLICE_JUNCTION:

                dataManager.initLoadOptions();

                clearCaches();

                break;

        }

    }

    /**

     * The visibility window has changed.

     */

    private void visibilityWindowChanged() {

        PreferenceManager prefs = PreferenceManager.getInstance();

        float maxRange = prefs.getAsFloat(PreferenceManager.SAM_MAX_VISIBLE_RANGE);

        minVisibleScale = (maxRange * 1000) / 700;

    }

    @Override

    public boolean handleDataClick(TrackClickEvent te) {

        MouseEvent e = te.getMouseEvent();

        if (Globals.IS_MAC && e.isMetaDown() || (!Globals.IS_MAC && e.isControlDown())) {