package calhoun.gebo.internal.db;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import calhoun.bean.AlignmentSegment;
import calhoun.gebo.model.Feature;
import calhoun.gebo.model.FeatureTrack;
import calhoun.gebo.model.Sequence;
import calhoun.gebo.model.Strand;
import calhoun.gebo.model.SubFeature;
import calhoun.gebo.util.C;
import calhoun.gebo.util.Informer;
import calhoun.gebo.util.S;
import calhoun.seq.Alignment;

public class AlignmentSpan extends CalhounFeature {

    private static Informer I = new Informer(AlignmentSpan.class);

    public AlignmentSpan(Sequence sequence, String label, String id, int start,
            int stop, FeatureTrack track, Strand strand, boolean updateable,
            boolean deletable, int editFlag) {
        super(sequence, label, id, start, stop, track, strand, false, false, 0);
    }

    public AlignmentSpan(Sequence sequence, FeatureTrack track,
            ResultSet resultSet) throws SQLException {
        super(sequence, track, resultSet, false, false, 0);
    }

    protected void appendAlignmentString(StringBuilder superB, String stringA,
            String stringB, Feature segment) {
        stringA = stringA.toUpperCase();
        stringB = stringB.toUpperCase();
        boolean debug = false;
//        if (getId().equals("7000000620763283")) {
//            debug = true;
//        }
        // I.warn("A: " + stringA);
        // I.warn("B: " + stringB);
        StringBuilder b = new StringBuilder();
        StringBuilder gap = new StringBuilder();
        int referenceIndex = 0;
        int referenceGapStart = 0;
        for (int i = 0; i < stringA.length(); i++) {
            char charA = stringA.charAt(i);
            char charB;
            if (stringB.length() > i) {
                charB = stringB.charAt(i);
            } else {
                charB = '-';
            }
            if (charA == '-') {
                if (charB != '-') {
                    if (debug) {
                        I.warn("ref gap vs: " + charB + " refIndex: "
                                + referenceIndex + " refGapA: "
                                + referenceGapStart + " gapLen: "
                                + gap.length());
                    }
                    if (referenceIndex > referenceGapStart + gap.length()) {
                        if (referenceGapStart > 0) {
                            if (debug) {
                                I
                                        .warn("!!!!!!!!!!!!!!!!! YABADABADOO DADING + "
                                                + referenceGapStart
                                                + ": "
                                                + gap.length()
                                                + "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
                            }
                            m_gapMap.put(getSequencePosition(segment,
                                    referenceGapStart), gap.toString());
                        }
                        gap = new StringBuilder();
                        referenceGapStart = referenceIndex + getGapStartFudge();
                    }
                    if (stringB.length() >= i + 1) {
                        gap.append(stringB.charAt(i));
                    } else {
                        gap.append("-");
                    }
                }
            } else {
                referenceIndex++;
                if (stringB.length() >= i + 1) {
                    b.append(charB + "");
                    if (charA != charB) {
                        // I.warn("charA !+ charB: " + charA + " != " + charB);
                        m_diffSet.add(getSequencePosition(segment,
                                referenceIndex));
                    }
                } else {
                    b.append("-");
                    m_diffSet.add(getSequencePosition(segment, referenceIndex));
                }
            }
        }
        if (gap.length() > 0) {
            m_gapMap.put(getSequencePosition(segment, referenceGapStart), gap
                    .toString());
        }
        if (getStrand().isMinus()) {
            superB.append(b.reverse());
        } else {
            superB.append(b);
        }
    }

    protected int getGapStartFudge() {
        return (getStrand().isMinus() ? 0 : 1);
    }

    protected int getSequencePosition(Feature segment, int i) {
        return segment.getSequencePosition(i - 1);
    }

    private Collection getOrderedSegments(calhoun.bean.AlignmentSpan bean) {
        if (!getStrand().isMinus()) {
            return bean.getSegments();
        } else {
            List list = new ArrayList();
            list.addAll(bean.getSegments());
            Collections.reverse(list);
            return list;
        }
    }

    public void createAlignmentString() {
        if (m_alignmentString == null) {
            try {
                if (((CalhounTrack) getTrack()).getTrackType()
                        .isAlignmentSpan()) {
                    StringBuilder b = new StringBuilder();
                    calhoun.bean.AlignmentSpan bean = (calhoun.bean.AlignmentSpan) CalhounConnectionManager
                            .getInstance().getDbSession().getById(
                                    calhoun.bean.AlignmentSpan.class, getId());
                    int lastStop = getStart();
                    for (Object o : getOrderedSegments(bean)) {
                        AlignmentSegment segment = (AlignmentSegment) o;
                        // b.append(segment.createAlignment().getTarget());
                        if (segment.getStart() > lastStop) {
                            b.append(S
                                    .x("-", segment.getStart() - lastStop - 1));
                        }
                        Alignment a = segment.createAlignment();
                        appendAlignmentString(b, a.getReference(), a
                                .getTarget(), getArgoAlignmentSegment(segment));
                        lastStop = segment.getStop();
                    }
                    m_alignmentString = b.toString();
                }
            } catch (Throwable t) {
                // I.warn("Error getting alignment string for " + getId());
                // return null;
            }
        }
    }

    protected Feature getArgoAlignmentSegment(AlignmentSegment segment) {
        for (SubFeature sf : getSubFeatures()) {
            if (sf.getId().equals(segment.getId())) {
                return sf;
            }
        }
        return null;

    }

    public String getAlignmentString(int a, int z) {
        try {
            createAlignmentString();
            if (m_alignmentString == null) {
                return S.x("?", z - a + 1);
            }
            a -= getStart();// - 1;
            z -= getStart() - 1;// - 1;
            // a--;
            // z--;
            // int requiredLength = z - a;
            if (z > m_alignmentString.length()) {
                // I.warn("cachedString: " + m_cachedAlignmentString.length()
                // + "requireLength: " + requiredLength);
                z = m_alignmentString.length();
            }
            return m_alignmentString.substring(a, z);
        } catch (Throwable t) {
            // I.warn("Error getting alignmentstring for " + getId() + "a..z : "
            // + a + ".." + z + "cache lenght: "
            // + m_cachedAlignmentString.length(), t);
            return S.x("?", z - a);
        }
    }

    public Map<Integer, String> getGapMap() {
        createAlignmentString();
        return m_gapMap;
    }

    public Set<Integer> getDiffSet() {
        createAlignmentString();
        return m_diffSet;
    }

    protected Set<Integer> m_diffSet = C.set();
    protected Map<Integer, String> m_gapMap = new HashMap<Integer, String>();
    protected String m_alignmentString;
}