package calhoun.gebo.internal.db;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import calhoun.gebo.api.AbstractTrackManager;
import calhoun.gebo.model.CompoundFeature;
import calhoun.gebo.model.Feature;
import calhoun.gebo.model.FeatureTrack;
import calhoun.gebo.model.RangeTrack;
import calhoun.gebo.model.Segment;
import calhoun.gebo.model.Sequence;
import calhoun.gebo.model.SequenceGroup;
import calhoun.gebo.model.Strand;
import calhoun.gebo.util.C;
import calhoun.gebo.util.Informer;
import calhoun.gebo.util.Q;
import calhoun.gebo.util.S;

public class CalhounPolymorphicTrackManager extends AbstractTrackManager {

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

    private CalhounPolymorphicTrackManager() {
        super("CalhounP", "CalhounP");
    }

    public static CalhounPolymorphicTrackManager getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new CalhounPolymorphicTrackManager();
        }
        return INSTANCE;
    }

    public RangeTrack[] getRangeTracks(SequenceGroup sequenceGroup) {
        List<RangeTrack> rangeTracks = C.list();
        for (FeatureTrack t : getTracks(sequenceGroup)) {
            CalhounPolymorphicTrack ct = (CalhounPolymorphicTrack) t;
            rangeTracks.add(ct.getRangeTrack());
        }
        return rangeTracks.toArray(new RangeTrack[0]);
    }

    private FeatureTrack[] getTracks(SequenceGroup sg) {
        if (m_tracksBySequenceGroup.containsKey(sg)) {
            return m_tracksBySequenceGroup.get(sg).toArray(new FeatureTrack[0]);
        }
        return new FeatureTrack[0];
    }

    public FeatureTrack[] getTracks(Sequence sequence) {
        return getTracks(sequence.getPrimarySequenceGroup());
    }

    public Feature[] getFeatures(Segment s, FeatureTrack t) {
        return getFeatures(s, t, t.isVisible());
    }

    public Feature[] getFeatures(Segment s, FeatureTrack t, boolean visible) {
        // I.warn("REINOS calling getFeatures");
        List<Feature> features = C.list();
        if (visible) {
            CalhounPolymorphicTrack polySiteTrack = (CalhounPolymorphicTrack) t;
            String bioSampleId = polySiteTrack.getBioSampleId();
            String sql = "\nselect " + "\nr.ap_feature_id as r_feature_id,"
                    + "\nq.ap_feature_id as q_feature_id," + "\nr.ap_name, "
                    + "\nr.ap_start," + "\nr.ap_stop," + "\nr.ap_strand,"
                    + "\nr.ap_sequence as r_sequence,"
                    + "\nq.ap_sequence as q_sequence,"
                    + "\nr.ap_conflicting as r_conflicting,"
                    + "\nq.ap_conflicting as q_conflicting from "
                    + "\nap_polymorphic_site_view r,"
                    + "\nap_polymorphic_site_view q" + "\nwhere "
                    + "\nr.ap_sequence_group = ?  "
                    + "\nand r.ap_sequence_id = ?"
                    + "\nand r.ap_polymorphism_id = q.ap_polymorphism_id"
                    + "\nand r.ap_start <=?" + "\nand r.ap_stop >= ?"
                    + "\nand q.ap_bio_sample_id = ?"
                    + "\nand r.ap_analysis_event_id = ?"
                    + "\nand r.ap_feature_id != q.ap_feature_id "
                    + "\nand r.ap_sequence != q.ap_sequence"
                    + "\norder by r.ap_start, q.ap_sequence";
            I.warn("REINOSNP: " + sql);
            I.setDebug(true);
            I.time("Getting SNP features for bioSampleId " + bioSampleId);
            try {
                PreparedStatement statement = CalhounConnectionManager
                        .getInstance().getConnection().prepareStatement(sql);
                Q.setStringOrNull(1, s.getSequence().getPrimarySequenceGroup()
                        .getId(), statement);
                Q.setLongOrNull(2, s.getSequence().getId(), statement);
                Q.setLongOrNull(3, s.getStop(), statement);
                Q.setLongOrNull(4, s.getStart(), statement);
                Q.setLongOrNull(5, bioSampleId, statement);
                Q.setLongOrNull(6, polySiteTrack.getQueryTrack()
                        .getParentAnalysisEventId(), statement);
                I.warn("1: "
                        + s.getSequence().getPrimarySequenceGroup().getId());
                I.warn("2: " + s.getSequence().getId());
                I.warn("3: " + s.getStop());
                I.warn("4: " + s.getStart());
                I.warn("5: " + bioSampleId);
                I.warn("6: "
                        + polySiteTrack.getQueryTrack()
                                .getParentAnalysisEventId());
                ResultSet resultSet = statement.executeQuery();
                while (resultSet.next()) {
                    String referenceId = resultSet.getString(1);
                    String queryId = resultSet.getString(2);
                    int start = resultSet.getInt(4);
                    int stop = resultSet.getInt(5);
                    Strand strand = Strand.parseStrand(resultSet.getString(6));
                    String rSequence = resultSet.getString(7);
                    String qSequence = resultSet.getString(8);
                    String name = qSequence + " vs. " + rSequence;
                    String rConflicting = resultSet.getString(9);
                    String qConflicting = resultSet.getString(10);
                    // conflict.
                    String id = referenceId + "_" + queryId;
                    Feature f = new CompoundFeature(s.getSequence(), name, id,
                            start, stop, t, strand);
                    f.setProperty("SEQUENCE", rSequence);
                    f.setProperty("ALT_SEQUENCE", qSequence);
                    f.setProperty("CONFLICTING", rConflicting);
                    f.setProperty("ALT_CONFLICTING", qConflicting);
                    f.setProperty("FEATURE_ID", referenceId);
                    f.setProperty("ALT_FEATURE_ID", queryId);
                    // f.setProperty("BIO_SAMPLE_ID", bioSampleId);
                    features.add(f);
                }
                I.time("Getting SNP features for bioSampleId " + bioSampleId);
                I.setDebug(false);
            } catch (Throwable x) {
                I
                        .error("Error getting Calhoun Polymorphic Features\n"
                                + sql, x);
            }
        }
        return features.toArray(new Feature[0]);
    }

    public FeatureTrack[] getTracks() {
        return null;
    }

    public void explode(CalhounTrack queryTrack, CalhounTrack nqsbTrack,
            SequenceGroup sg) throws SQLException {
        // List<FeatureTrack> explodedTracks = C.list();
        if (!m_tracksBySequenceGroup.containsKey(sg)) {
            m_tracksBySequenceGroup.put(sg, new ArrayList<FeatureTrack>());
        }
        FeatureTrack polyTrack = new CalhounPolymorphicTrack(queryTrack,
                nqsbTrack);
        // + bioSampleDescription, 0, "");
        // mact.setTemplateTrack(explodingTrack);
        // explodedTracks.add(polyTrack);
        m_tracksBySequenceGroup.get(sg).add(polyTrack);
    }

    public static String getBioSampleId(CalhounTrack ct) {
        String sql = "select ap_bio_sample_id from ap_polymorphic_site_view where ap_analysis_event_id = ?";
        String bioSampleId = null;
        try {
            Q.startStopWatch(sql);
            PreparedStatement statement = CalhounConnectionManager
                    .getInstance().getConnection().prepareStatement(sql);
            Q.setIntOrNull(1, ct.getAnalysisEventId(), statement);
            ResultSet resultSet = statement.executeQuery();
            if (resultSet.next()) {
                bioSampleId = resultSet.getString(1);
            }
        } catch (Throwable t) {
            I.error("Unable to get bio sample id for analysis event "
                    + ct.getAnalysisEventId());
        } finally {
            Q.stopStopWatch(sql);
        }
        return bioSampleId;
    }

    private static CalhounPolymorphicTrackManager INSTANCE;
    private Map<SequenceGroup, List<FeatureTrack>> m_tracksBySequenceGroup = new HashMap<SequenceGroup, List<FeatureTrack>>();

}