/*
 * Created on Nov 1, 2004
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */

/*
 The Broad Institute
 SOFTWARE COPYRIGHT NOTICE AGREEMENT
 This software and its documentation are copyright (2006) by the
 Broad Institute/Massachusetts Institute of Technology. All rights are
 reserved.

 This software is supplied without any warranty or guaranteed support
 whatsoever. Neither the Broad Institute nor MIT can be responsible for its
 use, misuse, or functionality.
 */

package calhoun.gebo.internal.db;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import calhoun.gebo.db.DataAccessException;
import calhoun.gebo.model.CompoundFeature;
import calhoun.gebo.model.CurationFlag;
import calhoun.gebo.model.Feature;
import calhoun.gebo.model.FeatureTrack;
import calhoun.gebo.model.Sequence;
import calhoun.gebo.model.Strand;
import calhoun.gebo.model.TranscriptType;
import calhoun.gebo.util.Informer;
import calhoun.gebo.util.U;
import calhoun.util.DbSession;

/**
 * @author reinhard
 * 
 * Superclass for fully editable manually annotated calhoun features. At the
 * moment there are 2 subtypes: AnnotatedTranscript (Eukaryotic) and ProGene
 * (Prokaryotic)
 */
public abstract class CalhounAnnotatedFeature extends CalhounFeature implements
        CalhounInsertableFeature, CalhounDeletableFeature {

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


    public CalhounAnnotatedFeature(Sequence sequence, FeatureTrack track,
            ResultSet resultSet, boolean updatable, boolean deletable,
            int editFlag) throws SQLException {
        super(sequence, track, resultSet, updatable, deletable, editFlag);
        getPrimaryEvidence();
        getSupplementalEvidence();
        getCurationFlags();
    }

    public CalhounAnnotatedFeature(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, updateable,
                deletable, editFlag);
    }

    public TranscriptType getTranscriptType() {
        if (m_transcriptType == null && existsInDB()) {
            TranscriptType[] transcriptTypes = getTM().getTranscriptTypes(
                    getCellType());
            for (int i = 0; i < transcriptTypes.length; i++) {
                if (transcriptTypes[i].getId().equals(
                        getPropertyValue(AP.TRANSCRIPT_TYPE_ID))) {
                    setTranscriptType(transcriptTypes[i]);
                }
            }
        }
        return m_transcriptType;
    }

    public void setTranscriptType(TranscriptType transcriptType) {
        m_transcriptType = transcriptType;
        setProperty(AP.TRANSCRIPT_TYPE, m_transcriptType.getLabel());
        setProperty(AP.TRANSCRIPT_TYPE_ID, m_transcriptType.getId());
    }

    public Feature[] getAllEvidence() {
        List list = new ArrayList();
        if (getPrimaryEvidence() != null) {
            list.add(getPrimaryEvidence());
        }
        Feature[] supplementalEvidence = getSupplementalEvidence();
        for (int i = 0; i < supplementalEvidence.length; i++) {
            list.add(supplementalEvidence[i]);
        }
        return (Feature[]) list.toArray(new Feature[0]);
    }

    public Feature getPrimaryEvidence() {
        if (m_primaryEvidence == null && existsInDB()) {
            String primaryEvidenceId = getPropertyValue(AP.PRIMARY_EVIDENCE_FEATURE_ID);
            if (primaryEvidenceId != null && !primaryEvidenceId.equals("")) {
                try {
                    Feature primaryEvidence = getTM().getFeature(
                            getSM(), primaryEvidenceId);
                    if (primaryEvidence == null) {
                        I.warn("Could not find primary evidence for id "
                                + primaryEvidenceId + " Parent Feature Id: "
                                + getId());
                    } else {
                        setPrimaryEvidence(primaryEvidence);
                    }
                } catch (Throwable t) {
                    I
                            .error(
                                    "Error attaching primary evidence id "
                                            + primaryEvidenceId
                                            + "\nHas this feature been deleted from the database?",
                                    t);
                }
            }
        }
        return m_primaryEvidence;
    }

    public void setPrimaryEvidence(Feature primaryEvidence) {

        if (!primaryEvidence.getTrack().isAdmissibleEvidence()) {
            I.error("Feature " + primaryEvidence
                    + " is not admissible evidence!");
            return;
        }

        m_primaryEvidence = primaryEvidence;
        setProperty("PRIMARY_EVIDENCE", primaryEvidence.getLabel());
        setProperty(AP.PRIMARY_EVIDENCE_FEATURE_ID, primaryEvidence.getId());
    }

    public abstract Feature[] getSupplementalEvidence();

    public boolean hasSupplementalEvidence() {
        return getSupplementalEvidence() != null
                && getSupplementalEvidence().length > 0;
    }

    public boolean hasPrimaryEvidence() {
        return getPrimaryEvidence() != null;
    }

    public abstract String getAccession();

    public void setSupplementalEvidence(Feature[] supplementalEvidence) {
        if (supplementalEvidence == null) {
            supplementalEvidence = new Feature[0];
        }

        for (int i = 0; i < supplementalEvidence.length; i++) {
            if (!supplementalEvidence[i].getTrack().isAdmissibleEvidence()) {
                I.error("Feature " + supplementalEvidence[i]
                        + " is not admissible evidence!");
                return;
            }
        }

        m_supplementalEvidence = supplementalEvidence;
        StringBuffer joinedEvidence = new StringBuffer();
        StringBuffer joinedEvidenceIds = new StringBuffer();
        for (int i = 0; i < m_supplementalEvidence.length; i++) {
            // I.warn(m_supplementalEvidence[0].dump());
            joinedEvidence.append(m_supplementalEvidence[i].getLabel());
            joinedEvidenceIds.append(m_supplementalEvidence[i].getId());
            if (i + 1 < m_supplementalEvidence.length) {
                joinedEvidence.append("; ");
                joinedEvidenceIds.append("#");
            }
        }
        setProperty("SUPPLEMENTAL_EVIDENCE", joinedEvidence.toString());
        setProperty("SUPPLEMENTAL_EVIDENCE_IDS", joinedEvidenceIds.toString());
    }

    public void addSupplementalEvidence(Feature feature) {
        if (feature.equals(getPrimaryEvidence())) {
            return;
        }
        Feature[] oldEvidence = getSupplementalEvidence();
        if (!U.contains(oldEvidence, feature)) {
            Feature[] newEvidence = new CompoundFeature[oldEvidence.length + 1];
            for (int i = 0; i < oldEvidence.length; i++) {
                newEvidence[i] = oldEvidence[i];
            }
            newEvidence[oldEvidence.length] = feature;
            setSupplementalEvidence(newEvidence);
        }
    }

    // Stuff for EditCacheManager

    public void restore() {
        restoreTranscriptType();
        restoreCurationFlags();
        restorePrimaryEvidence();
        restoreSupplementalEvidence();
    }

    private void restorePrimaryEvidence() {
        String id = getPropertyValue(AP.PRIMARY_EVIDENCE_FEATURE_ID);
        if (id != null && !id.equals("")) {
            setPrimaryEvidence(getTM().getFeature(getSM(), id));
        }
    }

    private void restoreTranscriptType() {
        TranscriptType[] transcriptTypes = getTM().getTranscriptTypes(
                getCellType());
        setTranscriptType((TranscriptType) U.identify(transcriptTypes,
                getPropertyValue("TRANSCRIPT_TYPE_ID")));
    }

    public abstract String update() throws DataAccessException;

    public abstract void review() throws DataAccessException;

    private void restoreSupplementalEvidence() {
        String value = getPropertyValue("SUPPLEMENTAL_EVIDENCE_IDS");
        if (value == null) {
            value = "";
        }
        String[] ids = value.split("#");
        if (ids.length > 0) {
            setSupplementalEvidence(getTM().getFeatures(getSM(), ids));
        }
    }

    protected void checkRetirementCode() {
        String comment = getPropertyValue(AP.RETIREMENT_COMMENT);
        String code = getPropertyValue(AP.RETIREMENT_CODE);
        if (comment == null) {
            setProperty(AP.RETIREMENT_COMMENT, "");
        }
        if (code == null || code.equals("")) {
            throw new Error("Missing retirement code!");
        }
    }

    protected CalhounSequenceManager getSM() {
        return CalhounSequenceManager.getInstance();
    }

    public void setCurationFlagsValid() {
        I.warn("calling setCurationFlagsValid");
        CurationFlag[] oldCurationFlags = getCurationFlags();
        CurationFlag[] newCurationFlags = new CurationFlag[oldCurationFlags.length + 1];
        newCurationFlags[0] = new CurationFlag("AUTO", "AUTO");
        for (int i = 0; i < oldCurationFlags.length; i++) {
            newCurationFlags[i + 1] = oldCurationFlags[i];
        }
        I.warn("old CurationFlagLength: " + oldCurationFlags.length);
        I.warn("new CurationFlagLength: " + newCurationFlags.length);
        setCurationFlags(newCurationFlags);
    }

    // public boolean is

    public void setEvidenceValid(boolean valid) {
        // I.success("setEvidenceValid: " + valid);
        DbSession s = CalhounConnectionManager.getInstance().getDbSession();
        Feature[] evidences = getAllEvidence();
        int i = 0;
        boolean invalidEvidencesFound = false;
        for (; i < evidences.length; i++) {
            String id = evidences[i].getId();
            calhoun.bean.Feature evidence = (calhoun.bean.Feature) s.getById(
                    calhoun.bean.Feature.class, id);
            try {
                invalidEvidencesFound = true;
                evidence.validate();
            } catch (Throwable t) {
                // I.success("setting invalid evidence: " + evidence);
                evidence.setInvalid(valid);
                s.save(evidence);
            }
        }
        if (invalidEvidencesFound) {
            s.commit();
        }

    }

    public boolean isEvidenceValid() {
        try {
            validateEvidence();
        } catch (Throwable t) {
            return false;
        }
        return true;
    }

    public abstract void performCalhounValidatation() throws Throwable;

    public List<Feature> getInvalidEvidence() {
        Feature[] evidences = getAllEvidence();
        int i = 0;
        List<Feature> invalidEvidenceList = new ArrayList();
        for (; i < evidences.length; i++) {
            String id = evidences[i].getId();
            calhoun.bean.Feature evidence = (calhoun.bean.Feature) CalhounConnectionManager
                    .getInstance().getDbSession().getById(
                            calhoun.bean.Feature.class, id);
            try {
                evidence.validate();
            } catch (Throwable t) {
                invalidEvidenceList.add(evidences[i]);
            }
        }
        return invalidEvidenceList;
    }

    private void validateEvidence() throws Throwable {
        List<Feature> invalidEvidence = getInvalidEvidence();
        if (invalidEvidence.size() > 0) {
            StringBuilder b = new StringBuilder();
            b.append("Transcript has invalid evidences: ");
            for (Feature e : invalidEvidence) {
                b.append(e.getLabel());
                b.append(" (");
                b.append(e.getId());
                b.append(") ");
            }
            throw new Exception(b.toString());
        }
    }

    protected Feature[] m_supplementalEvidence;
    private Feature m_primaryEvidence;
    private TranscriptType m_transcriptType;
}