/**
 * 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;

import java.util.*;
import java.util.Map.Entry;
import org.apache.ibatis.session.SqlSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import uk.ac.roslin.ensembl.config.EnsemblCoordSystemType;
import uk.ac.roslin.ensembl.config.EnsemblDBType;
import uk.ac.roslin.ensembl.config.FeatureType;
import uk.ac.roslin.ensembl.dao.database.factory.DBDAOCollectionCoreFactory;
import uk.ac.roslin.ensembl.dao.database.factory.DBDAOCollectionFactory;
import uk.ac.roslin.ensembl.dao.factory.DAOCollectionCoreFactory;
import uk.ac.roslin.ensembl.datasourceaware.DAAnalysis;
import uk.ac.roslin.ensembl.datasourceaware.core.DAAssembledDNASequence;
import uk.ac.roslin.ensembl.datasourceaware.core.DAChromosome;
import uk.ac.roslin.ensembl.datasourceaware.core.DACoordinateSystem;
import uk.ac.roslin.ensembl.exception.ConfigurationException;
import uk.ac.roslin.ensembl.exception.DAOException;
import uk.ac.roslin.ensembl.mapper.XRefMapper;
import uk.ac.roslin.ensembl.model.ExternalDB;
import uk.ac.roslin.ensembl.model.ObjectType;
import uk.ac.roslin.ensembl.model.core.CollectionSpecies;
import uk.ac.roslin.ensembl.model.core.CoordinateSystem;
import uk.ac.roslin.ensembl.model.core.Species;
import uk.ac.roslin.ensembl.model.database.CollectionCoreDatabase;
import uk.ac.roslin.ensembl.model.database.Registry;

/**
 *
 * @author paterson
 */
public class DBCollectionCoreDatabase extends DBCollectionDatabase implements CollectionCoreDatabase {

    final static Logger LOGGER = LoggerFactory.getLogger(DBCollectionCoreDatabase.class);
    
    private TreeMap<DBCollectionSpecies, TreeMap<Integer, DACoordinateSystem>> CSHash = new TreeMap<DBCollectionSpecies, TreeMap<Integer, DACoordinateSystem>>();

    private TreeMap<DBCollectionSpecies, DACoordinateSystem> seqLevelCSHash = new TreeMap<DBCollectionSpecies, DACoordinateSystem>();
    private TreeMap<DBCollectionSpecies, DACoordinateSystem> chrLevelCSHash = new TreeMap<DBCollectionSpecies, DACoordinateSystem>();
    private TreeMap<DBCollectionSpecies, DACoordinateSystem> topLevelCSHash = new TreeMap<DBCollectionSpecies, DACoordinateSystem>();
    private TreeMap<CollectionSpecies, DAOCollectionCoreFactory> factoryHash = new TreeMap<CollectionSpecies, DAOCollectionCoreFactory>();
    private TreeMap<DBCollectionSpecies, HashMap<FeatureType, HashMap<DACoordinateSystem, Integer>>>  featureCSHash
                = new TreeMap<DBCollectionSpecies, HashMap<FeatureType, HashMap<DACoordinateSystem, Integer>>>();

    private TreeMap<DBCollectionSpecies, HashMap<DACoordinateSystem, List<FeatureType>>>    CSFeatureHash
            = new TreeMap<DBCollectionSpecies, HashMap<DACoordinateSystem, List<FeatureType>>>();


//    private TreeMap<DBCollectionSpecies, String> speciesGeneBuildLevelHash = new TreeMap<DBCollectionSpecies, String>();
//    private TreeMap<DBCollectionSpecies, String> speciesExonBuildLevelHash = new TreeMap<DBCollectionSpecies, String>();
//    private TreeMap<DBCollectionSpecies, String> speciesTranscriptBuildLevelHash = new TreeMap<DBCollectionSpecies, String>();

    private TreeMap<DBCollectionSpecies, HashMap<FeatureType, String>> speciesBuildLevels = new TreeMap<DBCollectionSpecies, HashMap<FeatureType,String>>();
    private HashMap<Integer, DAAnalysis> analyses = null;;

    /**
     * A Map of ExternalDB objects on their id (previously used the db_name field in the database
     * table 'external_db' - but this was not unique due to versioning)
     */
    HashMap<Integer, ExternalDB> externalDBsByID = new HashMap<Integer, ExternalDB>();
    //unfortunately names may not be unique - e.g. multiple versions of PFAM
    HashMap<String, Set<ExternalDB>> externalDBsByName = new HashMap<String, Set<ExternalDB>>();
    boolean externalDBsInitialized = false; 
    
//    HashMap<CollectionSpecies, String> assemblyAccessionsMap = new HashMap<CollectionSpecies, String>();
//    HashMap<CollectionSpecies, String> assemblyNamesMap = new HashMap<CollectionSpecies, String>();
    
    public DBCollectionCoreDatabase(String db_name, EnsemblDBType type, Registry registry) throws ConfigurationException {
        super(db_name, type, registry);
    }

    @Override
    public DBDAOCollectionCoreFactory getCoreFactory(Species sp) {

        
        
        if (sp == null || collection == null || !this.collection.getSpecies().contains(sp)) {
            return null;
        }

        CollectionSpecies species = (CollectionSpecies) sp;

        if (this.factoryHash.containsKey(species)) {
            return (DBDAOCollectionCoreFactory) this.factoryHash.get(species);
        } else {
            DBDAOCollectionCoreFactory f = null;

            try {
                f = (DBDAOCollectionCoreFactory) DBDAOCollectionFactory.makeFactory(this, species);
                this.factoryHash.put(species, f);
            } catch (Exception ex) {
            }
            return f;

        }
    }

    @Override
    public DACoordinateSystem getChromosomeLevelCS(Species species) throws DAOException {

        if (species == null || this.collection == null || !this.getCollection().getSpecies().contains(species)) {
            return null;
        }

        DBCollectionSpecies sp = (DBCollectionSpecies) species;

        if (!this.chrLevelCSHash.containsKey(sp)) {
            this.lazyLoadCoordinateSystems(sp);
        }

        return this.chrLevelCSHash.get(sp);

    }

    @Override
    public DACoordinateSystem getSequenceLevelCS(Species species) throws DAOException {

        if (species == null || this.collection == null || !this.getCollection().getSpecies().contains(species)) {
            return null;
        }
        DBCollectionSpecies sp = (DBCollectionSpecies) species;
        if (!this.seqLevelCSHash.containsKey(sp)) {
            this.lazyLoadCoordinateSystems(sp);
        }

        return this.seqLevelCSHash.get(sp);
    }

    @Override
    public DACoordinateSystem getTopLevelCS(Species species) throws DAOException {

        if (species == null || this.collection == null || !this.getCollection().getSpecies().contains(species)) {
            return null;
        }
        DBCollectionSpecies sp = (DBCollectionSpecies) species;
        if (!this.topLevelCSHash.containsKey(sp)) {
            this.lazyLoadCoordinateSystems(sp);
        }

        return this.topLevelCSHash.get(sp);
    }

    private List<DACoordinateSystem> fetchCS(DBCollectionSpecies species) throws DAOException {

        List<DACoordinateSystem> coords = new ArrayList<DACoordinateSystem>();
        if (species == null || collection == null || !this.collection.getSpecies().contains(species)) {
            return coords;
        }

        //can throw DAOException
        if (this.getCoreFactory(species) != null) {
            coords =  (List<DACoordinateSystem>) this.getCoreFactory(species).getCoordinateSystemDAO().
                    getCoordinateSystems();
        } else {
           return coords;
        }
        return coords;
    }

    private void lazyLoadCoordinateSystems(DBCollectionSpecies species) throws DAOException {

        if (species == null || collection == null || !this.collection.getSpecies().contains(species)) {
            return;
        }

        List<DACoordinateSystem> coords = this.fetchCS(species);

        if (!coords.isEmpty()) {
            this.setCoordinateSystems(species, coords);
        }

        //set null values to prevent repeating lazy load

        if (!this.chrLevelCSHash.containsKey(species)) {
            this.chrLevelCSHash.put(species, null);
        }
        if (!this.topLevelCSHash.containsKey(species)) {
            this.topLevelCSHash.put(species, null);
        }
        if (!this.seqLevelCSHash.containsKey(species)) {
            this.seqLevelCSHash.put(species, null);
        }

    }

    private void setCoordinateSystems(DBCollectionSpecies species, List<DACoordinateSystem> coords) throws DAOException {

        if (species == null || collection == null || !this.collection.getSpecies().contains(species)) {
            return;
        }

        TreeMap<Integer, DACoordinateSystem> rankedCoordSystemsHash = new TreeMap<Integer, DACoordinateSystem>();
        TreeMap<Integer, DACoordinateSystem> idCoordSystemsHash = new TreeMap<Integer, DACoordinateSystem>();

        //set  the top, chromosome and sequence levels

        for (DACoordinateSystem cs : coords) {
            rankedCoordSystemsHash.put(cs.getRank(), cs);
            idCoordSystemsHash.put(cs.getId(), cs);
        }
        
        //note 'toplevel' default CS is actually that with 'lowestrank'
        for (Entry<Integer, DACoordinateSystem> e :rankedCoordSystemsHash.entrySet()) {
                if (e.getValue().isDefaultVersion()) {
                    e.getValue().setTopLevel(true);
                    this.topLevelCSHash.put(species, e.getValue());
                    break;
                }
        }        
        
        //the lowest ranked default chromosome CS 
        for (Entry<Integer, DACoordinateSystem> e : rankedCoordSystemsHash.entrySet()) {
                if (e.getValue().getType() == EnsemblCoordSystemType.chromosome
                        && e.getValue().isDefaultVersion()) {
                    this.chrLevelCSHash.put(species, e.getValue());
                    break;
                }
        }        
        
        //the (lowest ranked) default seq_level CS
        for (Entry<Integer, DACoordinateSystem> e :rankedCoordSystemsHash.entrySet()) {
                if (e.getValue().isSequenceLevel()
                        && e.getValue().isDefaultVersion()) {
                    this.seqLevelCSHash.put(species, e.getValue());
                    break;
                }
        }
     
        this.CSHash.put(species, idCoordSystemsHash);
    }

    @Override
    public void setBuildLevels(Species species, HashMap<String, String> keyedValues) {

        if (species == null || collection == null || !this.collection.getSpecies().contains(species)
                || keyedValues == null || keyedValues.isEmpty()) {
            return;
        }

        HashMap<FeatureType, String> map = new HashMap<FeatureType, String>();

        for (String key : keyedValues.keySet()) {

            String temp = key.replace("build.level", "");

            if (FeatureType.getFeatureType(temp) != null) {
                map.put(FeatureType.getFeatureType(temp), keyedValues.get(key));
            }

        }

        this.speciesBuildLevels.put((DBCollectionSpecies) species, map);
    }

    @Override
    @SuppressWarnings("element-type-mismatch")
    public String getBuildLevel(Species species, String featureKey) throws DAOException {

        if (species == null || collection == null || !this.collection.getSpecies().contains(species)) {
            return null;
        }

        String out = null;

        if (this.speciesBuildLevels.get(species) != null) {
            out = this.speciesBuildLevels.get(species).get(FeatureType.getFeatureType(featureKey));
        }
        return out;
    }

    //dont really want this public - just for testing
    public HashMap<FeatureType, String> getBuildLevels(CollectionSpecies species) {
        if (species == null || collection == null || !this.collection.getSpecies().contains(species)) {
            return null;
        }
        return this.speciesBuildLevels.get(species);
    }

    private void setFeatureCSHash(DBCollectionSpecies sp) throws DAOException {

        if (sp == null || collection == null || !this.collection.getSpecies().contains(sp)) {
            return;
        }

        if (!this.CSHash.containsKey(sp)) {
            this.lazyLoadCoordinateSystems(sp);
        }


        HashMap<DACoordinateSystem, List<FeatureType>> hash1 = new HashMap<DACoordinateSystem, List<FeatureType>>();

        for (DACoordinateSystem c : this.CSHash.get(sp).values()) {
            hash1.put(c, new ArrayList<FeatureType>());

        }

        this.CSFeatureHash.put(sp, hash1);

        this.featureCSHash.put(sp, new HashMap<FeatureType, HashMap<DACoordinateSystem, Integer>>());

        try {

            this.getCoreFactory(sp).getCoordinateSystemDAO().setFeatureCS();

        } catch (DAOException e) {
            throw e;
        }

    }

    @Override
    public void addFeatureCS(String featureType, Integer csID, Integer maxLength, Species sp) {

        if (sp == null || collection == null || !this.collection.getSpecies().contains(sp)) {
            return;
        }

        FeatureType localType = null;
        DACoordinateSystem cs = null;

        localType = FeatureType.getFeatureType(featureType);
        cs = this.CSHash.get(sp).get(csID);

        if (localType == null || cs == null) {
            return;
        } else {
            if (!this.featureCSHash.get(sp).containsKey(localType)) {
                this.featureCSHash.get(sp).put(localType, new HashMap<DACoordinateSystem, Integer>());
            }
            this.featureCSHash.get(sp).get(localType).put(cs, maxLength);

            this.CSFeatureHash.get(sp).get(cs).add(localType);

        }


    }


    @Override
    public Set<DACoordinateSystem> getCSForFeature(Species sp, ObjectType feature) throws DAOException {

        if (sp == null || collection == null || !this.collection.getSpecies().contains(sp)) {
            return null;
        }

        if (!this.featureCSHash.containsKey(sp)) {
            this.setFeatureCSHash((DBCollectionSpecies) sp);
        }


        if (this.featureCSHash.containsKey(sp)
                && this.featureCSHash.get(sp).containsKey(feature)) {
            return this.featureCSHash.get(sp).get(feature).keySet();
        } else {

            return null;
        }
    }

    @Override
    public List<FeatureType> getFeaturesForCS(Species sp, CoordinateSystem coordSys) throws DAOException {

        if (sp == null || collection == null || !this.collection.getSpecies().contains(sp)) {
            return null;
        }

        if (!this.featureCSHash.containsKey(sp)) {
            this.setFeatureCSHash((DBCollectionSpecies) sp);
        }

        if (this.CSFeatureHash.containsKey(sp)
                && this.CSFeatureHash.get(sp).containsKey(coordSys)) {
            return this.CSFeatureHash.get(sp).get(coordSys);
        } else {
            return null;
        }
    }

    @Override
    public Integer getMaxLengthForFeature(Species sp, ObjectType feature, CoordinateSystem cs) throws DAOException {

        if (sp == null || collection == null || !this.collection.getSpecies().contains(sp)) {
            return null;
        }

        if (feature == null || cs == null) {
            return null;
        }

        if (!this.featureCSHash.containsKey(sp)) {
            this.setFeatureCSHash((DBCollectionSpecies) sp);
        }

        if (this.featureCSHash.containsKey(sp)
                && this.featureCSHash.get(sp).containsKey(feature)
                && this.featureCSHash.get(sp).get(feature).containsKey(cs)) {
            return this.featureCSHash.get(sp).get(feature).get(cs);
        } else {
            return null;
        }

    }

    @Override
    public DACoordinateSystem getBuildCoordSystem(Species species, String featureType) throws DAOException {

        if (species == null || collection == null || !this.collection.getSpecies().contains(species)
                || this.speciesBuildLevels.get(species) == null
                || featureType == null || featureType.isEmpty()) {
            return null;
        }

        if (FeatureType.getFeatureType(featureType) != null) {
            String level = this.speciesBuildLevels.get(species).get(FeatureType.getFeatureType(featureType));
            if (level.equalsIgnoreCase("toplevel")) {
                return this.topLevelCSHash.get(species);
            } else {
                return null;
            }

//                //are there other values possible?
//                else if (level.equalsIgnoreCase("chromosomelevel")) {
//                    return this.getChromosomeLevelCoordSystem();
//                } else if (level.equalsIgnoreCase("sequencelevel")) {
//                    return this.getSequenceLevelCoordSystem();
//                }
        }

        return null;
    }

    @Override
    public DACoordinateSystem getCSByID(Species species, Integer id) throws DAOException {

        if (species == null || collection == null || !this.collection.getSpecies().contains(species)
                || id == null) {
            return null;
        }

        DACoordinateSystem out = null;
        if (!this.CSHash.containsKey(species)) {

            //lazyload can throw DAOException
            this.lazyLoadCoordinateSystems((DBCollectionSpecies) species);

        }
        
        if (this.CSHash.containsKey(species) ) {
           out = this.CSHash.get(species).get(id); 
        }

        return out;
    }

    @Override
    public DAChromosome getChromosomeByName(Species species, String name) throws DAOException {

       if (species == null || collection == null || !this.collection.getSpecies().contains((DBCollectionSpecies) species)) {
            return null;
        }

        if (this.getCoreFactory(species)== null 
                || this.getCoreFactory(species).getDatabase() ==null) {
            return null;
        }
        return (DAChromosome) this.getCoreFactory(species).getChromosomeDAO().getChromosomeByName(name);

    }

    @Override
    public List<DAChromosome> getChromosomes(Species species) throws DAOException {

        if (species == null || collection == null || !this.collection.getSpecies().contains(species)) {
            return null;
        }

        if (this.getCoreFactory(species)== null 
                || this.getCoreFactory(species).getDatabase() ==null) {
                return new ArrayList<DAChromosome>();
        }
        
        return  this.getCoreFactory(species).getChromosomeDAO().getChromosomes();

    }

    @Override
    public DAAssembledDNASequence getFragmentByName(Species species, String name) throws DAOException {

        if (species == null || collection == null || !this.collection.getSpecies().contains(species)) {
            return null;
        }

        if (this.getCoreFactory(species) == null
                || this.getCoreFactory(species).getDatabase() ==null) {
            return null;
        }
        return (DAAssembledDNASequence) this.getCoreFactory(species).getChromosomeDAO().getFragmentByName(name);

    }

    @Override
    public List<DAAssembledDNASequence> getFragments(Species species) throws DAOException {

        if (species == null || collection == null || !this.collection.getSpecies().contains(species)) {
            return null;
        }

        if (this.getCoreFactory(species) == null
                || this.getCoreFactory(species).getDatabase() ==null) {
            return new ArrayList<DAAssembledDNASequence>();
        }

        return ((DBDAOCollectionCoreFactory) this.getCoreFactory(species)).getChromosomeDAO().getFragments();

    }
    
    /**
     * Analyses are cached at the Database level
     * 
     * @throws DAOException 
     */
    @Override
    public HashMap<Integer, DAAnalysis> getAnalyses() throws DAOException {
        if (analyses!= null) {
            return analyses;
        }
        
        //there is only one set of analyses - not one per species 
        //so we dont need a species context for this query
        DBCollectionSpecies sp = null;
        try {
            sp = collection.getSpecies().first();
        } catch (Exception e) {
            LOGGER.info("Something wrong with the Collection of Species for this Database: "+this.getdBName(), e);
        }
        if (sp != null && this.getCoreFactory(sp)!=null){
            analyses = this.getCoreFactory(sp).getAnalysisDAO().getAnalyses();
         } else {
            LOGGER.info("Failed to get a populated list of Analyses for this Database: "+this.getdBName());
            analyses = new HashMap<Integer, DAAnalysis>();
        }
        return analyses;
    }

    /**
     * Validates a givenExternalDB object, to return a pre-existing version id present. 
     * @param db
     *  
     */
    @Override
    public ExternalDB validateExternalDB(ExternalDB db) {
        
        if (db==null) {
            return null;
        }
        
        this.initializeExternalDBs();
        
        if (this.externalDBsByID.containsKey(db.getId())) {
            return this.externalDBsByID.get(db.getId());
        } else {
            this.externalDBsByID.put(db.getId(), db);
            return db;
        }
    }
    
    @Override
    public void initializeExternalDBs()  {
        if (this.externalDBsInitialized) {
            return;
        }
        
        List<ExternalDB> result = null;
        SqlSession session = null;

        try {
            session = this.getNewSqlSession();
            XRefMapper mapper = session.getMapper(XRefMapper.class);
            result= mapper.getExternalDBs(); 
        } catch (Exception e) {
            LOGGER.debug("Failed to call getExternalDBs on DBDatabase", e);
            return;
            //throw new DAOException("Failed to call getExternalDBs on DBDatabase", e);
        } finally {
            if (session != null) {
                session.close();
            }
        }

        if (result!=null && !result.isEmpty()) {
            for (ExternalDB d:result) {
            this.externalDBsByID.put(d.getId(), d); 

            if (!this.externalDBsByName.containsKey(d.getDBName())) {
                this.externalDBsByName.put(d.getDBName(), new HashSet<ExternalDB>());
            }
            this.externalDBsByName.get(d.getDBName()).add(d); 
            }
        }       
        
        this.externalDBsInitialized = true;
    }
    
    @Override
    public ExternalDB getExternalDB(Integer id) {
        this.initializeExternalDBs();
        return this.externalDBsByID.get(id);
    }
    
   /**
    * Returns the AssemblyAccession value for this species. (This method is maintained purely for
    * equivalence to the SingelSpecies Database, lazy loading is not performed by the CollectionDatabase
    * as this property should be filled in on initialisation).
    * @param species
    * @return 
    */
    @Override
    public String getAssemblyAccession(CollectionSpecies species) {
        return species != null && this.collection != null 
                && this.collection.getSpecies().contains(species) 
                ? species.getAssemblyAccession(dbVersion) : null;
       //return this.assemblyAccessionsMap.get(species);
    }

    
    /**
    * Returns the AssemblyName value for this species. (This method is maintained purely for
    * equivalence to the SingelSpecies Database, lazy loading is not performed by the CollectionDatabase
    * as this property should be filled in on initialisation).
    * @param species
    * @return 
    */
    @Override
    public String getAssemblyName(CollectionSpecies species) {
        return species != null && this.collection != null 
                && this.collection.getSpecies().contains(species) 
                ? species.getAssemblyName(dbVersion) : null;
        //return this.assemblyNamesMap.get(species);
    }

//    @Override
//    public void setAssemblyName(CollectionSpecies species, String value) {
//        this.assemblyNamesMap.put(species, value);
//    }
//
//    @Override
//    public void setAssemblyAccession(CollectionSpecies species,String value) {
//        this.assemblyAccessionsMap.put(species, value);
//    }    
}