/**
 * 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.dao.database.compara;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.TreeMap;
import org.apache.ibatis.session.SqlSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import uk.ac.roslin.ensembl.config.EnsemblComparaDivision;
import uk.ac.roslin.ensembl.dao.compara.HomologyDAO;
import uk.ac.roslin.ensembl.dao.database.DBBaseDAO;
import uk.ac.roslin.ensembl.dao.database.DBSpecies;
import uk.ac.roslin.ensembl.dao.factory.DAOComparaFactory;
import uk.ac.roslin.ensembl.datasourceaware.compara.DAHomologyPairRelationship;
import uk.ac.roslin.ensembl.datasourceaware.compara.InverseHomologyPairRelationshipView;
import uk.ac.roslin.ensembl.datasourceaware.core.DADNASequence;
import uk.ac.roslin.ensembl.datasourceaware.core.DAGene;
import uk.ac.roslin.ensembl.exception.DAOException;
import uk.ac.roslin.ensembl.exception.NonUniqueException;
import uk.ac.roslin.ensembl.mapper.compara.HomologyPairMapper;
import uk.ac.roslin.ensembl.model.Coordinate;
import uk.ac.roslin.ensembl.model.Mapping;
import uk.ac.roslin.ensembl.model.MappingSet;
import uk.ac.roslin.ensembl.model.compara.HomologyAlignmentProperties;
import uk.ac.roslin.ensembl.model.core.DNASequence;
import uk.ac.roslin.ensembl.model.core.Gene;
import uk.ac.roslin.ensembl.model.core.Species;


public class DBHomologyDAO extends DBBaseDAO implements HomologyDAO {

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

    //If we really want to cache here we will need to use a singleton DBHomologyDAO
    TreeMap<String, DAGene> localGeneCache = new TreeMap<String, DAGene>();

    EnsemblComparaDivision comparaDivision;
    String sourceVersion = "";

    public DBHomologyDAO(DAOComparaFactory factory) throws DAOException {
        super(factory);
        comparaDivision = factory.getComparaDivision();
        sourceVersion = this.getFactory().getDBVersion();
    }

    /**
     * Data Access method to retrieve all of the homologies
     * (i.e. to all species) for a given gene with a stableID.
     * @param g The query Gene
     * @return List of HomologyPairRelationships
     * @throws DAOException 
     */    
    @Override
    public List<DAHomologyPairRelationship> getHomologiesForGene(Gene g) throws DAOException {

        DAGene gene = (DAGene) g;
        
        //this tests for the field used by mybatis
        if (gene.getStableID()==null || gene.getStableID().isEmpty()) {
            throw new DAOException("Failed to get homologies for a gene without a stable EnsemblID");
        }

        List<DAHomologyPairRelationship> results = new ArrayList<DAHomologyPairRelationship>();
        SqlSession session = null;

        try {
            session = this.getFactory().getNewSqlSession();
            HomologyPairMapper mapper = session.getMapper(HomologyPairMapper.class);
            results = mapper.getHomologiesForGene(g);
        } catch (Exception e) {
            throw new DAOException("Failed to call getHomologiesForGene(g) on HomologyDAO", e);
        } finally {
            if (session != null) {
                session.close();
            }
        }

        //do i want to do this - or to throw an exception to indicate something
        //has gone wrong with the DB call
        if (results==null) {
            return new ArrayList<DAHomologyPairRelationship>();
        }

        for (DAHomologyPairRelationship h : results) {

            Species sp = null;
            //the DAO must have a factory or it wouldn't get here
            //and we 'should' always have a registry on a factory
            //we use this to get the species for the homologous gene (i.e from the registry)
            //but we can return null here

                try {
                    sp = this.getFactory().getRegistry().getSpeciesByAlias(h.getTargetProperties().getSpeciesName());
                } catch (NonUniqueException ex) {
                    LOGGER.debug(ex.getMessage());
                    for (Object s : ex.getAllHits()) {
                        LOGGER.debug(((DBSpecies)s).getDatabaseStyleName());                   
                    }
                    //not sure what to do here if the name is not unique....
                    //
                    //continue;
                }

            if (sp == null) {
                //make a 'dummy species' - this wont have a factory!
                sp = new DBSpecies();
                ((DBSpecies) sp).setComparaName(sourceVersion, h.getTargetProperties().getSpeciesName());
            }

            h.setSource(gene);

            DAGene target = new DAGene();
            target.setDBVersion( this.getFactory().getDBVersion());
            target.setStableID(h.getTargetProperties().getGeneID());
            target.setSpecies(sp);

            //hopefully there will only be one relationship to a given target gene
            //but just in case
            if (localGeneCache.containsKey(target.getStableID())) {
                target = localGeneCache.get(target.getStableID());
            } else {
               localGeneCache.put(target.getStableID(),target );
            }


            h.setTarget(target);

            //fill in the sourceProperties that are not filled in by sql
            //but are needed once we reverse the relationship
            HomologyAlignmentProperties sourceProperties = h.getSourceProperties();


            try {
                sourceProperties.setSequenceName(
                        ((DADNASequence)gene.getAnnotationLevelMappings().first().getTarget()).getName());
                sourceProperties.setCoords(
                        gene.getAnnotationLevelMappings().first().getTargetCoordinates());
            } catch (Exception e) {
                LOGGER.warn("Gene "+gene.getHashID()+ " has no annotation level coordinates.");
            }
            sourceProperties.setSpeciesName(
                    (gene.getSpecies()!= null) ? gene.getSpecies().getComparaName(sourceVersion) : ""
                    );

//            //reverse the relationship
//            DAHomologyPairRelationship reverse = new DAHomologyPairRelationship();
//            reverse.setSource(target);
//            reverse.setTarget(gene);
//            //these arent treversable - use the same type??
//            //i.e the type one2many is not necessarily specified the correct way
//            reverse.setRelationshipType(h.getRelationshipType());
//            reverse.setTargetProperties(h.getSourceProperties());
//            reverse.setSourceProperties(h.getTargetProperties());
//            reverse.setLastCommonAncestor(h.getLastCommonAncestor());
//            reverse.setId(h.getId());
//
//            //add the reversed relationship
//            target.addHomology(comparaDivision, reverse);

            //this doesnt reverse the direction of the relationship
            //maybe i do want to do this - and remember that i have to look at
            //relationships either way
            target.addHomology(comparaDivision, new InverseHomologyPairRelationshipView(h));

        }
        return results;
    }
    
    /**
     * Data Access method to retrieve all of the homologies
     * in the specified target species for a List of genes with stableIDs.
     * @param genes theList of query genes
     * @param target_sp The target Species
     * @param chrName The target chromosome name
     * @return List of HomologyPairRelationships
     * @throws DAOException 
     */
    @Override
    public List<DAHomologyPairRelationship> 
            getHomologiesForGenesBySpecies(List<? extends Gene> genes, Species target_sp, String chrName) 
            throws DAOException {


        
        if (genes==null || genes.isEmpty()) {
            throw new DAOException("Failed to get homologies: No Genes specified");
        }
        
        HashMap<String,DAGene> geneMap = new HashMap<String,DAGene>();
        
        if (target_sp==null ) {
            throw new DAOException("Failed to get homologies: no target Species specified");
        }
        if (target_sp.getComparaName(sourceVersion) == null 
                || target_sp.getComparaName(sourceVersion).isEmpty()) {
            throw new DAOException("Failed to get homologies: target Species not identified in Compara source");
        }
        
        HashMap<String, Object> query = new HashMap<String, Object>();
        
        query.put("targetSpecies", target_sp.getComparaName(sourceVersion));

        
        for (Gene g : genes) {
            if (!((DAGene)g).getStableID().isEmpty()) {

                geneMap.put(((DAGene)g).getStableID(), (DAGene) g);
            }
        }
        
        if (geneMap.isEmpty()) {
            throw new DAOException("Failed to get homologies: No Genes specified");
        }
        
        query.put("geneIDs",new ArrayList(geneMap.keySet()) );
        
        if (chrName !=null && !chrName.isEmpty()) {
            query.put("chrName", chrName);
        }
        
        List<DAHomologyPairRelationship> results = new ArrayList<DAHomologyPairRelationship>();
        SqlSession session = null;

        try {
            session = this.getFactory().getNewSqlSession();
            HomologyPairMapper mapper = session.getMapper(HomologyPairMapper.class);
            results = mapper.getHomologiesForGenesBySpecies(query);
        } catch (Exception e) {
            throw new DAOException("Failed to call getSpeciesHomologiesForGenes(HashMap) on HomologyDAO", e);
        } finally {
            if (session != null) {
                session.close();
            }
        }

        //do i want to do this - or to throw an exception to indicate something
        //has gone wrong with the DB call
        if (results==null) {
            return new ArrayList<DAHomologyPairRelationship>();
        }

        for (DAHomologyPairRelationship h : results) {

            DAGene sourceGene = geneMap.get(h.getSourceProperties().getGeneID());

            h.setSource(sourceGene);

            DAGene targetGene = new DAGene();
            targetGene.setDBVersion( this.getFactory().getDBVersion());
            targetGene.setStableID(h.getTargetProperties().getGeneID());
            targetGene.setSpecies(target_sp);

            //hopefully there will only be one relationship to a given target gene
            //but just in case
            if (localGeneCache.containsKey(targetGene.getStableID())) {
                targetGene = localGeneCache.get(targetGene.getStableID());
            } else {
               localGeneCache.put(targetGene.getStableID(),targetGene );
            }


            h.setTarget(targetGene);

            //fill in the sourceProperties that are not filled in by sql
            //but are needed once we reverse the relationship
            HomologyAlignmentProperties sourceProperties = h.getSourceProperties();


            try {
                sourceProperties.setSequenceName(
                        ((DADNASequence)sourceGene.getAnnotationLevelMappings().first().getTarget()).getName());
                sourceProperties.setCoords(
                        sourceGene.getAnnotationLevelMappings().first().getTargetCoordinates());
            } catch (Exception e) {
                LOGGER.warn("Gene "+sourceGene.getHashID()+ " has no annotation level coordinates.");
            }
            sourceProperties.setSpeciesName(
                    (sourceGene.getSpecies()!= null) ? sourceGene.getSpecies().getComparaName(sourceVersion) : ""
                    );

//            //reverse the relationship
//            DAHomologyPairRelationship reverse = new DAHomologyPairRelationship();
//            reverse.setSource(target);
//            reverse.setTarget(gene);
//            //these arent treversable - use the same type??
//            //i.e the type one2many is not necessarily specified the correct way
//            reverse.setRelationshipType(h.getRelationshipType());
//            reverse.setTargetProperties(h.getSourceProperties());
//            reverse.setSourceProperties(h.getTargetProperties());
//            reverse.setLastCommonAncestor(h.getLastCommonAncestor());
//            reverse.setId(h.getId());
//
//            //add the reversed relationship
//            target.addHomology(comparaDivision, reverse);

            //this doesnt reverse the direction of the relationship
            //maybe i do want to do this - and remember that i have to look at
            //relationships either way
            
            //we havent done a complete search for the division for all species
            //so store result with a specieal key
            //targetGene.addHomology(comparaDivision, new InverseHomologyPairRelationshipView(h));
            sourceGene.addHomology(EnsemblComparaDivision.INCOMPLETE_SEARCH,h);
            targetGene.addHomology(EnsemblComparaDivision.INCOMPLETE_SEARCH, new InverseHomologyPairRelationshipView(h));

        }
        return results;
    }
        
    /**
    * Data Access method to retrieve all of the regions on DNASequences
    * for the specified target species, holding genes with homologies to genes found
    * in the given region of the source query sequence. 
    * @param source DNASequence to be queried
    * @param range Coordinate range of query sequence to be queried
    * @param target the target species
    * @return HashMap of Syntenic regions against the set of Mappings holding homologous genes
    * @throws DAOException 
    */    
    @Override
    public HashMap<DADNASequence, MappingSet> getRegionsOfConservedSynteny(DNASequence source, Coordinate range,
            Species target) throws DAOException {
        return this.getRegionsOfConservedSynteny(source, range, target, null);
    }

   /**
    * Data Access method to retrieve any potential region of 
    * conserved synteny on a given Chromosome/fragment 
    * for the specified target species, holding genes with homologies to genes found
    * in the given region of the source query sequence. 
    * @param source DNASequence to be queried
    * @param range Coordinate range of query sequence to be queried
    * @param target the target species
    * @param chrName the target chromosome name
    * @return HashMap of Syntenic regions against the set of Mappings holding homologous genes
    * @throws DAOException 
    */
    @Override
    public HashMap<DADNASequence, MappingSet>
            getRegionsOfConservedSynteny(DNASequence source, Coordinate range, Species target, String chrName) 
            throws DAOException {

        DADNASequence sChr;
        DBSpecies tSp;
        String tChr;

        if (source==null || target==null) {
            throw new DAOException("Require a source chromosome and a target species to call getRegionsOfConservedSynteny");
        }

        try {
            sChr = (DADNASequence) source;
            tSp = (DBSpecies) target;
            tChr = chrName;
        } catch (Exception e) {
            throw new DAOException("failed to pass valid parameters to get Regions of Conserved Synteny", e);
        }

        HashMap<DADNASequence, MappingSet> syntenies = new HashMap<DADNASequence, MappingSet>();

        if (range == null || range.getStart() == null || range.getEnd() == null) {
            range = new Coordinate(sChr.getBioBegin(), sChr.getBioEnd(), 1);
        }

        List<DAGene> sGenes = sChr.getGenesOnRegion(range);

        if (sGenes == null || sGenes.isEmpty()) {
            return syntenies;
        }
        
        List<DAHomologyPairRelationship> speciesHomologiesForGenes = this.getHomologiesForGenesBySpecies(sGenes, target, tChr);

        //old way recursed through the genes...
        //for (DAGene g : sGenes) {
            //List<DAHomologyPairRelationship> l = g.getHomologies(this.comparaDivision, tSp);

            for (DAHomologyPairRelationship hpr : speciesHomologiesForGenes) {
                //force conversion to real mappings, re-using cached chromosomes if appropriate
                MappingSet m = null;
                try {
                    //get annotation level mappingsof the target (homologous) gene
                    //i.e. gene-> chromosome in general?
                    m = hpr.getTarget().getAnnotationLevelMappings();
                } catch (DAOException dAOException) {
                }
                if (m != null && !m.isEmpty()) {
                    //probably only one of these?
                    for (Mapping mp : m) {
                       DADNASequence dna = (DADNASequence) mp.getTarget();
                       if (!syntenies.containsKey(dna)) {
                           //if we are using the gene->chr mappings we need to be sorting on the target coords
                           //syntenies.put(dna, new MappingSet(Mapping.mappingOnTargetComparator));
                           //but if we are using the chr->gene mappings we can sort on the source coords (i.e. default comparator)
                           syntenies.put(dna, new MappingSet());
                       }
                       // this adds the mapping hom_gene->chr
                       //syntenies.get(dna).add(mp);
                       //but we want the mapping chr->hom_gene

                       //this method is called within the getReverseMapping method if required!
                       //Mapping.addReverseMapping(mp);
                       syntenies.get(dna).add(mp.getReverseMapping());
                    }
                }
                // incase there are no mappings for the homologous genes on a chromosome!
                else
                {
                    //what do we do
                }
            }
        //}
        return syntenies;
    }
    
}