/**
 * 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 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.DBDAOSingleSpeciesCoreFactory;
import uk.ac.roslin.ensembl.dao.database.factory.DBDAOSingleSpeciesFactory;
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.CoordinateSystem;
import uk.ac.roslin.ensembl.model.database.Registry;
import uk.ac.roslin.ensembl.model.database.SingleSpeciesCoreDatabase;

/**
 *
 * @author paterson
 */
public class DBSingleSpeciesCoreDatabase extends DBSingleSpeciesDatabase implements SingleSpeciesCoreDatabase {

    private List<DACoordinateSystem> coordSystems = new ArrayList<DACoordinateSystem>();
    private TreeMap<Integer, DACoordinateSystem> rankedCoordSystemsHash = new TreeMap<Integer, DACoordinateSystem>();
    private TreeMap<Integer, DACoordinateSystem> idCoordSystemsHash = new TreeMap<Integer, DACoordinateSystem>();
    private Integer chromosomeLevelID = null;
    private Integer sequenceLevelID = null;
    private Integer topLevelID = null;
    private DACoordinateSystem chromosomeLevelCS = null;
    private DACoordinateSystem sequenceLevelCS = null;
    private DACoordinateSystem topLevelCS = null;
    private HashMap<FeatureType, String> defaultBuildLevels = new HashMap<FeatureType, String>();
    private HashMap<FeatureType, HashMap<DACoordinateSystem, Integer>> featureCSHash = null;
    private HashMap<DACoordinateSystem, List<FeatureType>> CSFeatureHash = null;
    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;   
    
    protected String assemblyName = null;
    protected String assemblyAccession = null;
    protected String comparaName = null;
        
    public DBSingleSpeciesCoreDatabase(String db_name, EnsemblDBType type, Registry registry) throws ConfigurationException {
        super(db_name, type, registry);
    }

    @Override
    public DBDAOSingleSpeciesCoreFactory getCoreFactory() {
        if (this.factory == null) {
            try {
                this.factory = DBDAOSingleSpeciesFactory.makeFactory(this);
            } catch (Exception ex) {
            }
        }

        if (this.factory != null) {
            return (DBDAOSingleSpeciesCoreFactory) this.factory;
        } else {
            return null;
        }
    }
    
    private List<DACoordinateSystem> fetchCS() throws DAOException {
        List<DACoordinateSystem> coords = new ArrayList<DACoordinateSystem>();
        //can throw DAOException
        if ( this.getCoreFactory()!=null) {
            coords = this.getCoreFactory().getCoordinateSystemDAO().
                getCoordinateSystems();
        } else {
           return coords;
        }        
        return coords;
    }
    
    private void setCoordinateSystems(List<DACoordinateSystem> coords) throws DAOException {

        this.coordSystems.clear();
        this.coordSystems.addAll(coords);

        //set  the ids for the top, chromosome and sequence levels

        for (DACoordinateSystem cs : coordSystems) {

            this.rankedCoordSystemsHash.put(cs.getRank(), cs);
            this.idCoordSystemsHash.put(cs.getId(), cs);

        }
        
        for (Entry<Integer, DACoordinateSystem> e : this.rankedCoordSystemsHash.entrySet() ) {
            if (e.getValue().isDefaultVersion()) {
                    e.getValue().setTopLevel(true);
                    this.topLevelCS = e.getValue();
                    this.topLevelID = e.getValue().getId();
                    break;
                }
        }
        
        for (Entry<Integer, DACoordinateSystem> e : this.rankedCoordSystemsHash.entrySet() ) {
            if (e.getValue().isDefaultVersion() 
                    && e.getValue().getType() == EnsemblCoordSystemType.chromosome) {             
                    this.chromosomeLevelCS = e.getValue();
                    this.chromosomeLevelID = e.getValue().getId();
                    break;
                }
        }
        
        for (Entry<Integer, DACoordinateSystem> e : this.rankedCoordSystemsHash.entrySet() ) {
            if (e.getValue().isDefaultVersion() 
                    && e.getValue().isSequenceLevel()) {
                    this.sequenceLevelCS = e.getValue();
                    this.sequenceLevelID = e.getValue().getId();
                    break;
                }
        }

    }

    private void lazyLoadCoordinateSystems() throws DAOException {

        this.coordSystems.clear();

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

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

        //set nil values to prevent repeating lazy load

        if (this.chromosomeLevelID == null) {
            this.chromosomeLevelID = 0;
        }
        if (this.topLevelID == null) {
            this.topLevelID = 0;
        }
        if (this.sequenceLevelID == null) {
            this.sequenceLevelID = 0;
        }
       
    }

    @Override
    public DACoordinateSystem getCSByID(Integer id) throws DAOException {
        DACoordinateSystem out = null;
        if (topLevelID == null && this.coordSystems.isEmpty()) {

                //lazyload can throw DAOException
                lazyLoadCoordinateSystems();

        }

        out = this.idCoordSystemsHash.get(id);

        return out;
    }
        
    public List<DACoordinateSystem> getCoordinateSystems() throws DAOException {
        
        if (topLevelID == null && this.coordSystems.isEmpty()) {
                //lazyload can throw DAOException
                lazyLoadCoordinateSystems();
        }
        return this.coordSystems;
    }   

    @Override
    public DACoordinateSystem getTopLevelCoordSystem() throws DAOException {
        if (topLevelID == null && this.coordSystems.isEmpty()) {
            //lazyload can throw DAOException
            lazyLoadCoordinateSystems();
        }
        return topLevelCS;
    }

    @Override
    public DACoordinateSystem getChromosomeLevelCoordSystem() throws DAOException {
        if (chromosomeLevelID == null && this.coordSystems.isEmpty()) {
            //lazyload can throw DAOException
            lazyLoadCoordinateSystems();
        }
        return chromosomeLevelCS;
    }

    @Override
    public DACoordinateSystem getSequenceLevelCoordSystem() throws DAOException {
        if (sequenceLevelID == null && this.coordSystems.isEmpty()) {
            //lazyload can throw DAOException
            lazyLoadCoordinateSystems();
        }
        return sequenceLevelCS;
    }

    @Override
    public DAChromosome getChromosomeByName(String name) throws DAOException {
        if (this.getCoreFactory()!=null){
            return this.getCoreFactory().getChromosomeDAO().getChromosomeByName(name);
        } else {
            return null;
        }

    }
    
    /**
     * a Fragment is TopLevelAssembledDNASequence ( where there are no chromosomes )
     * @param name
     * 
     * @throws DAOException 
     */
    @Override
    public DAAssembledDNASequence getFragmentByName(String name) throws DAOException {
        if (this.getCoreFactory()!=null){
            return this.getCoreFactory().getChromosomeDAO().getFragmentByName(name);
        } else {
            return null;
        }

    }

    /**
     * Note that Chromosomes are not cached by the Database object - but by the Species Object
     * 
     * @throws DAOException 
     */
    @Override
    public List<DAChromosome> getChromosomes() throws DAOException {
        if (this.getCoreFactory()!=null){
            return this.getCoreFactory().getChromosomeDAO().getChromosomes();
         } else {
            return new ArrayList<DAChromosome>();
        }
    }
        
    /**
     * Fragments are TopLevelAssembledDNASequences
     * 
     * @throws DAOException 
     */
    @Override
    public List<DAAssembledDNASequence> getFragments() throws DAOException {
        if (this.getCoreFactory()!=null){
            return this.getCoreFactory().getChromosomeDAO().getFragments();
         } else {
            return new ArrayList<DAAssembledDNASequence>();
        }
    }

    private void setFeatureCSHash() throws DAOException {

        if (sequenceLevelID == null && this.coordSystems.isEmpty()) {
            //lazyload can throw DAOException
            lazyLoadCoordinateSystems();
        }

        featureCSHash = new HashMap<FeatureType, HashMap<DACoordinateSystem, Integer>>();
        CSFeatureHash = new HashMap<DACoordinateSystem, List<FeatureType>>();

        for (DACoordinateSystem c : this.coordSystems) {
            CSFeatureHash.put(c, new ArrayList<FeatureType>());

        }


        if (this.getCoreFactory() != null) {

            try {

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

            } catch (DAOException e) {
                featureCSHash = null;
                CSFeatureHash = null;
                throw e;
            }
        }

    }

    @Override
    public Set<DACoordinateSystem> getCSForFeature(ObjectType featureType) throws DAOException {

            if (this.featureCSHash == null) {
                this.setFeatureCSHash();
            }


        if (this.featureCSHash != null
                && this.featureCSHash.containsKey(featureType)) {
            return this.featureCSHash.get(featureType).keySet();
        } else {

            return null;
        }
    }

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


            if (this.featureCSHash == null) {
                this.setFeatureCSHash();
            }


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

    @Override
    public Integer getMaxLengthForFeature(ObjectType featureType, CoordinateSystem cs) throws DAOException {

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

            if (this.featureCSHash == null) {
                this.setFeatureCSHash();
            }



        if (this.featureCSHash != null
                && this.featureCSHash.containsKey(featureType)
                && this.featureCSHash.get(featureType).containsKey(cs)) {
            return this.featureCSHash.get(featureType).get(cs);
        } else {
            return null;
        }

    }

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

        FeatureType type = null;
        DACoordinateSystem cs = null;

        type = FeatureType.getFeatureType(featureType);
        cs = this.idCoordSystemsHash.get(csID);

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

            this.CSFeatureHash.get(cs).add(type);

        }


    }

    @Override
    public void setBuildLevel(String featureKey, String level) {
        String temp = featureKey.replace("build.level", "");

        if (FeatureType.getFeatureType(temp) != null) {
            this.defaultBuildLevels.put(FeatureType.getFeatureType(temp), level);
        }
    }

    @Override
    public String getBuildLevel(String featureType) throws DAOException{
        if (FeatureType.getFeatureType(featureType) != null) {
            if (defaultBuildLevels.isEmpty()) {
                this.getRegistry().setSpeciesMetadata(this);
            }
            return this.defaultBuildLevels.get(FeatureType.getFeatureType(featureType));
        } else {
            return null;
        }
    }

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

            if (FeatureType.getFeatureType(featureType) != null) {
                if (defaultBuildLevels.isEmpty()) {
                    this.getRegistry().setSpeciesMetadata(this);
                }
                String level = this.defaultBuildLevels.get(FeatureType.getFeatureType(featureType));
                if (level != null && level.equalsIgnoreCase("toplevel")) {
                    return this.getTopLevelCoordSystem();
                } 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;

    }

    //dont really want this public - just for testing
    public HashMap<FeatureType, String> getBuildLevels() {
        if (defaultBuildLevels.isEmpty()) {
            try {
                
                //is this correct - dont i want to do 
                //this.getRegistry().setCoreDBBuildLevels(this);
                lazyLoadCoordinateSystems();
            } catch (DAOException ex) {
                
            }
        }
        return defaultBuildLevels;
    }

    /**
     * Analyses are cached at the Database level
     * 
     * @throws DAOException 
     */
    @Override
    public HashMap<Integer, DAAnalysis> getAnalyses() throws DAOException {
        if (analyses!= null) {
            return analyses;
        }
        if (this.getCoreFactory()!=null){
            analyses =  this.getCoreFactory().getAnalysisDAO().getAnalyses();
         } else {
            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);
    }

    @Override
    public String getAssemblyName() {
        if (assemblyName == null) {
            try {
                this.lazyLoadMetadata();
            } catch (DAOException e) {
                //probably should throw this
            }
        }
        return assemblyName;
    }   
    
    @Override
    public String getComparaName() {
        if (comparaName == null) {
            try {
                this.lazyLoadMetadata();
            } catch (DAOException e) {
                //probably should throw this
            }
        }
        return comparaName;
    }
    
    @Override
    public String getAssemblyAccession() {        
        if (assemblyAccession == null) {
            try {
                this.lazyLoadMetadata();
            } catch (DAOException e) {
                //probably should throw this
            }
        }
        return assemblyAccession;
    }

    public void lazyLoadMetadata() throws DAOException  {
        this.getRegistry().setSpeciesMetadata(this);
        if (assemblyName==null) {assemblyName ="";}
        if (assemblyAccession==null) {assemblyAccession ="";}
        if (comparaName==null) {comparaName ="";}
    }

    @Override
    public void setAssemblyName(String value) {
        assemblyName = value;
    }
    
    @Override
    public void setAssemblyAccession(String value) {
        assemblyAccession = value;
    }
    
    @Override
    public void setComparaName(String value) {
        comparaName = value;
    }
    
    
}