/**
 * Copyright (C) 2010-2015 The Roslin Institute <contact andy.law@roslin.ed.ac.uk>
 *
 * This file is part of JEnsembl: a Java API to Ensembl data sources developed by the
 * Bioinformatics Group at The Roslin Institute, The Royal (Dick) School of
 * Veterinary Studies, University of Edinburgh.
 *
 * Project hosted at: http://jensembl.sourceforge.net
 *
 * This is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License (version 3) as published by
 * the Free Software Foundation.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * in this software distribution. If not, see: http://opensource.org/licenses/gpl-3.0.html
 */
package uk.ac.roslin.ensembl.datasourceaware.core;

import java.util.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import uk.ac.roslin.ensembl.config.DBConnection;
import uk.ac.roslin.ensembl.config.EnsemblComparaDivision;
import uk.ac.roslin.ensembl.config.ExternalDBType;
import uk.ac.roslin.ensembl.config.FeatureType;
import uk.ac.roslin.ensembl.dao.factory.DAOCoreFactory;
import uk.ac.roslin.ensembl.datasourceaware.DAXRef;
import uk.ac.roslin.ensembl.datasourceaware.compara.DAHomologyPairRelationship;
import uk.ac.roslin.ensembl.exception.DAOException;
import uk.ac.roslin.ensembl.model.ObjectType;
import uk.ac.roslin.ensembl.model.XRef;
import uk.ac.roslin.ensembl.model.XRefed;
import uk.ac.roslin.ensembl.model.core.CollectionSpecies;
import uk.ac.roslin.ensembl.model.core.Gene;
import uk.ac.roslin.ensembl.model.core.Species;
import uk.ac.roslin.ensembl.model.core.Transcript;
import uk.ac.roslin.ensembl.model.core.VegaFeature;

public class DAGene extends DAAnalyzedFeature implements Gene, VegaFeature, XRefed {

    private String biotype = null;
    private Integer canonicalTranscriptID = null;
    private DATranscript canonicalTranscript = null;
    private TreeMap<Integer, DATranscript> transcriptHash = null;
    private HashMap<EnsemblComparaDivision, List<DAHomologyPairRelationship>> homologies =
            new HashMap<EnsemblComparaDivision, List<DAHomologyPairRelationship>>();
    private TreeSet<EnsemblComparaDivision> homologySearchesPerformed = new TreeSet<EnsemblComparaDivision>();
    
    private TreeSet<String> synonyms = null;
    protected  Set<DAXRef> xrefs = new HashSet<DAXRef>();
    protected HashMap<ExternalDBType, Set<DAXRef>> typedXRefs = new HashMap<ExternalDBType, Set<DAXRef>>();
    boolean xrefsInitialized = false;   
    private Integer orthologueCount = null;
    private Integer paralogueCount = null;
    private Integer homoeologueCount = null;
    private String vegaGeneID =null;

    final static Logger LOGGER = LoggerFactory.getLogger(DAGene.class);

    public DAGene() {
        super();
    }

    public DAGene(DAOCoreFactory factory) {
        super(factory);
     }

    @Override
    public ObjectType getType() {
        return FeatureType.gene;
    }

    @Override
    public String getBiotype() {
        if (this.biotype==null) {
            this.reinitialize();
        }
        return this.biotype;
    }

    public void setBiotype(String biotype) {
        this.biotype = biotype;
    }

    @Override
    public Collection<DATranscript> getTranscripts() {
        if (transcriptHash == null) {

            try {
                transcriptHash = new TreeMap<Integer, DATranscript>();
                return (Collection<DATranscript> ) this.getDaoFactory().getTranscriptDAO().getTranscriptsForGene(this);             
            } catch (Exception e) {
                transcriptHash = new TreeMap<Integer, DATranscript>();
                LOGGER.info("Threw DAOException on trying to populate transcripts for a Gene", e);
            }
        }
        
        return this.transcriptHash.values();
    }

    public void addTranscript(Transcript transcript) {
        if (transcriptHash==null) {
            transcriptHash = new TreeMap<Integer, DATranscript>();
        }
        try {
            DATranscript t = (DATranscript) transcript;
            this.transcriptHash.put(t.getId(), t);
        } catch (Exception e) {
            LOGGER.info("failed to add a transcript to the Gene", e);
        }
    }

    @Override
    public DATranscript getCanonicalTranscript() {
        
        if (this.canonicalTranscript != null) {
            return this.canonicalTranscript;
        }
        //force reinitialization
        if (this.getCanonicalTranscriptID()==null || this.canonicalTranscriptID.equals(0)) {
            return null;
        }
        //get all of the transcripts not just the canonical one!
        this.getTranscripts(); 
        
        if (this.canonicalTranscript==null && this.canonicalTranscriptID!=null ) {
            this.canonicalTranscript = this.transcriptHash.get(this.canonicalTranscriptID);
        }
        return this.canonicalTranscript;
      
    }
    
    public void setCanonicalTranscript (DATranscript transcript) {
        this.canonicalTranscript = transcript;
    }
    

    @Override
    public String getStableID() {
        //can't reinitialize if we dont have the stableID
        return stableID;
    }

    @Override
    public void setStableID(String stableID) {
        this.stableID = stableID;
    }

    public Integer getCanonicalTranscriptID() {
        if (this.canonicalTranscriptID==null) {
           this.reinitialize(); 
        }
        return canonicalTranscriptID;
    }

    public void setCanonicalTranscriptID(Integer canonicalTranscriptID) {
        this.canonicalTranscriptID = canonicalTranscriptID;
    }

    @Override
    public DATranslation getCanonicalTranslation() {
        if (this.getCanonicalTranscript() != null) {
            return this.getCanonicalTranscript().getCanonicalTranslation();
        } else {
            return null;
        }
    }
    
    /**
     * Note the special case for Bacteria in collections in DB >16
     * @return 
     */
    @Override
    public EnsemblComparaDivision getComparaDivision() {
        
       if (this.getSpecies() != null && this.getSpecies() instanceof CollectionSpecies
                && Integer.parseInt(this.getDBVersion())>16) {
            return EnsemblComparaDivision.PAN_HOMOLOGY;
       } else if (this.getSpecies() != null) {
            return this.getSpecies().getComparaDivision();
       }  
       return null;
    }
    /**
     * Returns all Homologies (as a List of HomologyPairRelationships) in the default
     * ComparaDivision for this Gene. Implemented by 
     * calling getHomologies(EnsemblComparaDivision comparaDivision) with
     * the default ComparaDivision for this Gene. 
     * 
     */
    @Override
    public List<DAHomologyPairRelationship> getHomologies() {
        return this.getHomologies(this.getComparaDivision());
    }

    /**
     * Returns all Homologies (as a List of HomologyPairRelationships) in the specified
     * ComparaDivision for this Gene.  
     * @param comparaDivision
     * 
     */
    @Override
    public List<DAHomologyPairRelationship> getHomologies(EnsemblComparaDivision comparaDivision) {

        List<DAHomologyPairRelationship> out = new ArrayList<DAHomologyPairRelationship>();
       
        if (comparaDivision==null) {
            return out;
        }
        
        if (comparaDivision.equals(EnsemblComparaDivision.PAN_HOMOLOGY)
                && !this.getSpecies().isInPanCompara(this.getDBVersion())) {
            return out;
        }

        if (!this.homologySearchesPerformed.contains(comparaDivision)) {

            if (this.getStableID() == null || this.getStableID().isEmpty()) {
                return out;
            }

            try {
                out = (List<DAHomologyPairRelationship>) this.getComparaFactory(comparaDivision).getHomologyDAO().getHomologiesForGene(this);
                this.homologySearchesPerformed.add(comparaDivision);
                //this would over write any existing... maybe ok!
                this.homologies.put(comparaDivision, out);

//                if (this.homologies.get(comparaDivision) == null) {
//                    this.homologies.put(comparaDivision, new ArrayList<DAHomologyPairRelationship>());
//                }
//                this.homologies.get(comparaDivision).addAll(out);

            } catch (Exception ex) {
                LOGGER.info("failed to get Homologies", ex);
            }

        }

        if (this.homologies.containsKey(comparaDivision)) {
            return this.homologies.get(comparaDivision);
        } else {
            return new ArrayList<DAHomologyPairRelationship>();
        }
    }


    /**
     * Returns Homologies (as a List of HomologyPairRelationships) in the default
     * ComparaDivision for this Gene for the specified Species. Implemented by 
     * calling getHomologies(EnsemblComparaDivision comparaDivision, Species sp) with
     * the default ComparaDivision for this Gene. 
     * @param sp
     * 
     */
    @Override
    public List<DAHomologyPairRelationship> getHomologies(Species sp) {
        return this.getHomologies(this.getComparaDivision(), sp);
    }

    /**
     * Returns Homologies (as a List of HomologyPairRelationships) in the specified
     * ComparaDivision for the specified Species.
     * Cos of the lack of indices it is much faster to implement using the query
     * to get  all homologues than restrict to a single gdb.name in the sql [unless
     * you do it by a specific subselect]. So to get homologues for a single species do
     * the whole query and do the filterring in the Java. This allows us to store
     * all homologies at once too.
     * @param comparaDivision
     * @param sp
     * 
     */
    @Override
    public List<DAHomologyPairRelationship> getHomologies(EnsemblComparaDivision comparaDivision, Species sp) {

        //make sure basic fetch is done
        this.getHomologies(comparaDivision);
        
        List<DAHomologyPairRelationship> out = new ArrayList<DAHomologyPairRelationship>();

        if (homologies.get(comparaDivision)!=null && !homologies.get(comparaDivision).isEmpty()) {
            for (DAHomologyPairRelationship r : homologies.get(comparaDivision)) {
                if (r.getTarget().getSpecies()!=null
                        && r.getTarget().getSpecies().equals(sp)) {
                    out.add(r);
                }
            }
        }
        return out;
    }


    public void addHomology(EnsemblComparaDivision division, DAHomologyPairRelationship homology) {

        if (this.homologies.get(division)==null) {
            this.homologies.put(division, new ArrayList<DAHomologyPairRelationship>());
        }
        this.homologies.get(division).add(homology);

    }

    public boolean setSearchedHomologies (EnsemblComparaDivision comparaDivision) {
        return this.homologySearchesPerformed.add(comparaDivision);
    }
    
    @Override
    void reinitialize()  { 
        if (!this.isLazyloadAllowed() || this.isInitialized()) {
            return;
        }
        try {
            //nb getDaoFactory() will try and make a factory if we have at least species and ensembl version
            this.getDaoFactory().getGeneDAO().reInitialize(this);
                       
        } catch (Exception ex) {
            LOGGER.info("Failed to reinitialize the Gene from the Database (using its stableID: "
                    +this.stableID+").", ex);
        } finally {
            //always set this so dont try again
            this.setInitialized(true);
        }
    }
    
    @Override
    public String getDisplayName() {
        this.reinitialize();
        return (displayName!=null) ? displayName : stableID ;
    }
    
    /**
     * Utility method to get all of the current DAHomologyPairRelationships for this Gene
     *
     * @return List<DAHomologyPair BinaryRelationship>
     */
    @Override
    public List<DAHomologyPairRelationship> getHomologiesWithoutLazyLoad() {

        List<DAHomologyPairRelationship> out = new ArrayList<DAHomologyPairRelationship>();

        for (EnsemblComparaDivision div: homologies.keySet()) {
                out.addAll(homologies.get(div));
        }
        return out;
    }
    
    /**
     * Returns preloaded XRefs of given type: Note - does not lazy load these
     * @param type
     */
    protected Set<DAXRef> getXRefs(ExternalDBType type) {
        return typedXRefs.get(type);
    }
    
    @Override
    public DAXRef getDisplayXRef() {
        this.reinitialize();
        return displayXRef;
    }

    public void setDisplayXRef(DAXRef xref) {
        this.displayXRef = xref;
        if (xref!=null) {
            this.xrefs.add(xref);
            Set s = new HashSet<DAXRef>();
            s.add(xref);
            this.typedXRefs.put(ExternalDBType.DisplayID, s);            
        }
    }    
    
    /**
     * Returns any curated VegaID for the Gene, forcing lazy load if not set, and defaulting 
     * to an empty string if absent (e.g. for all the invertebrate species in EnsemblGenomes).
     * @return String the VegaID of this Gene
     */
    @Override 
    public String getVegaID() {
        
        if (this.vegaGeneID!=null) {
            return this.vegaGeneID;
        }
        
        List<DAXRef> outList = new ArrayList<DAXRef>();
        
        if (this.getDaoFactory()!= null 
                && !this.getDaoFactory().getRegistry().getDatasourceType().equals(DBConnection.DataSource.ENSEMBLDB)) {
            this.vegaGeneID="";
            this.addTypedXRefs(ExternalDBType.VegaGene, outList);
            return vegaGeneID;
        }
        
        this.reinitialize();
               
        if (this.vegaGeneID==null ) {
            
            if (this.getDaoFactory()!= null && this.getId()!=null) {                
                     
                  for (DAXRef dax : this.getAllXRefs()) {
                        if (dax.getPrimaryAccession()!=null
                                && dax.getPrimaryAccession().startsWith("OTT")
                                && dax.getDB()!= null  
                                && (dax.getDB().getDBName().equals(ExternalDBType.VegaGene.toString())
                                    ||
                                    dax.getDB().getDBName().contains("Vega_gene") 
                                    ||
                                    dax.getDB().getDBName().contains("vega_gene") )
                                ) {
                            outList.add(dax);
                            }
                  }

                
                if (outList.isEmpty()) {
                    this.vegaGeneID = "";
                    this.addTypedXRefs(ExternalDBType.VegaGene, outList);
                    return this.vegaGeneID;
                } else {
                    //add the factory to the xref - although we shouldn't need to use it as it is fully initialized
                    for (DAXRef xr: outList) {
                        xr.setDaoFactory(this.getDaoFactory());
                    }
                    this.addTypedXRefs(ExternalDBType.VegaGene, outList);
                }

                if (outList.size()==1) {
                    this.vegaGeneID = outList.get(0).getPrimaryAccession().trim();
                    return this.vegaGeneID;
                } else {
                    //hopefully all the IDs will be the same - but can't guarantee this!
                    String pre = "Multiple Vega IDs: {";
                    boolean multiple = false;
                    String out = null;
                    String firstID = "";
                    
                    for (XRef x: outList) {
                        if (out==null) {
                            out = x.getPrimaryAccession().trim();
                            firstID = x.getPrimaryAccession().trim(); 
                        } else if (!firstID.equals(x.getPrimaryAccession().trim())) {                        
                            out = out.concat(", ").concat(x.getPrimaryAccession().trim());
                            multiple  = true;
                        }
                    }
                    
                    if (!multiple) {
                        vegaGeneID=out;
                    } else {
                        out = out.trim().concat("}");
                        vegaGeneID = pre.concat(out);
                    }
                    return this.vegaGeneID;
                }
            }          
        }
        return this.vegaGeneID;
    }

    @Override
    public Set<DAXRef> getVegaXRefs() {
        //getting the VegaID lazyloads both the VegaID and the Vega XRefs
        this.getVegaID();
        return this.getXRefs(ExternalDBType.VegaGene);
    }
      
    @Override
    public Set<DAXRef> getAllXRefs() {

        if (this.xrefsInitialized) {
            return xrefs;
        }

        this.reinitialize();

        if (this.getDaoFactory() != null && this.getId() != null) {
            List<DAXRef> result = null;
            try {
                result = (List<DAXRef>) this.getDaoFactory().getXRefDAO().getAllXRefs(this);

            } catch (DAOException ex) {
                LOGGER.info("Threw DAOException on trying to get Vega ID for Feature: " + this.getStableID(), ex);
            } finally {
                this.xrefsInitialized = true;
            }

            if (result == null || result.isEmpty()) {
                return xrefs;
            } else {
                
                for (DAXRef xr : result) {
                    //add the factory to the xref - although we shouldn't need to use it as it is fully initialized
                    xr.setDaoFactory(this.getDaoFactory());
                    //check that we are not creating duplicate External DBs...
                    
                      /* shouldn't be necessary now */        
//                    ExternalDB db = xr.getDB();
//                    int originalHashCode = db.originalHashCode();
//                    db  = this.getDaoFactory().getDatabase().validateExternalDB(db);
//                    int checkedHashCode = db.originalHashCode();
//                    if (originalHashCode-checkedHashCode !=0) {
//                        System.out.println("*** FAILED TO REUSE EXTERNALDB");
//                    } else {
//                        System.out.println("*** successfully reused externaldb");
//                    }
//                    xr.setDB(db);
                    xrefs.add(xr);
                    }
                }
        }
        return xrefs;
    }
    
    @Override
    public TreeSet<String> getAllSynonyms() {

        if (synonyms!=null) {
            return synonyms;
        }
        this.reinitialize();
        try {
            synonyms = this.getDaoFactory().getXRefDAO().getAllSynonyms(this);
        } catch (DAOException ex) {
            LOGGER.debug("Failed to getAllSynonyms for DAFeature", ex);
        }
        if (synonyms==null) {
            synonyms = new TreeSet<String>();
        }
        return synonyms;
    }
    
    @Override
    public TreeSet<String> getSynonyms(XRef xref) {
        return xref.getSynonyms();
    }       
        
    protected void addTypedXRefs(ExternalDBType type, Collection<? extends XRef> xrefs) {
        if ( this.typedXRefs.get(type)==null) {
            this.typedXRefs.put(type, new HashSet<DAXRef>());
        }
        this.typedXRefs.get(type).addAll((Collection<DAXRef>)xrefs);
    }

    public Integer getOrthologueCount() {
        if (orthologueCount==null && this.getDaoFactory()!= null 
                && Integer.parseInt(this.getDaoFactory().getEnsemblSchemaVersion()) > 75 ) {
            this.reinitialize();
        }
        return orthologueCount;
    }

    public void setOrthologueCount(Integer orthologueCount) {
        this.orthologueCount = orthologueCount;
    }

    public Integer getParalogueCount() {
        if (paralogueCount==null && this.getDaoFactory()!= null 
                && Integer.parseInt(this.getDaoFactory().getEnsemblSchemaVersion()) > 75 ) {
            this.reinitialize();
        }
        return paralogueCount;
    }

    public void setParalogueCount(Integer paralogueCount) {
        this.paralogueCount = paralogueCount;
    }

    public Integer getHomoeologueCount() {
        if (homoeologueCount==null && this.getDaoFactory()!= null 
                && Integer.parseInt(this.getDaoFactory().getEnsemblSchemaVersion()) > 75 ) {
            this.reinitialize();
        }
        return homoeologueCount;
    }

    public void setHomoeologueCount(Integer homoeologueCount) {
        this.homoeologueCount = homoeologueCount;
    }
    
    
}