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

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.AssemblyExceptionType;
import uk.ac.roslin.ensembl.config.EnsemblCoordSystemType;
import uk.ac.roslin.ensembl.dao.coreaccess.ChromosomeDAO;
import uk.ac.roslin.ensembl.dao.factory.DAOCollectionCoreFactory;
import uk.ac.roslin.ensembl.dao.factory.DAOCoreFactory;
import uk.ac.roslin.ensembl.dao.factory.DAOSingleSpeciesCoreFactory;
import uk.ac.roslin.ensembl.datasourceaware.core.DAAssembledDNASequence;
import uk.ac.roslin.ensembl.datasourceaware.core.DAChromosome;
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.mapper.core.ChromosomeMapper;
import uk.ac.roslin.ensembl.mapper.handler.DBResultHandler;
import uk.ac.roslin.ensembl.model.Coordinate;
import uk.ac.roslin.ensembl.model.Mapping;
import uk.ac.roslin.ensembl.model.core.Chromosome;
import uk.ac.roslin.ensembl.model.core.CoordinateSystem;

/**
 *
 * @author paterson
 */
public class DBChromosomeDAO extends DBCoreObjectDAO implements ChromosomeDAO {

    final static Logger LOGGER = LoggerFactory.getLogger(DBChromosomeDAO.class);
    
    public DBChromosomeDAO() {
        super();
    }

    public DBChromosomeDAO(DAOSingleSpeciesCoreFactory factory) {
        super(factory);
    }

    public DBChromosomeDAO(DAOCollectionCoreFactory factory)  {
        super(factory);
    }

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

        if (name==null || name.isEmpty()) {
            return null;
        }

        DAChromosome out = null;
        String chrName = name;
        CoordinateSystem chrCS = null;

        if (singleSpecies) {
            chrCS = ssFactory.getDatabase().getChromosomeLevelCoordSystem();
        } else {
            chrCS = collFactory.getDatabase().getChromosomeLevelCS(species);
        }

        if (chrCS==null || chrCS.getId()==null  ) {
            throw new DAOException("Failed to call to retrieve the CoordinateSystem for Chromosomes");
        }

        Integer chrCSID = chrCS.getId();

        HashMap parameters = new HashMap();
        parameters.put("chrName",chrName);
        parameters.put("coordSysID", chrCSID);

        SqlSession session = null;

        try {
            session = this.getFactory().getNewSqlSession();
            ChromosomeMapper mapper = session.getMapper(ChromosomeMapper.class);
            out = mapper.getChromosomeByName_CoordSysID(parameters);
        } catch (Exception e) {
            throw new DAOException("Failed to call getChromsomeByName_CoordSysID", e);
        } finally {
            if (session != null) {
                session.close();
            }
        }

        if (out != null) {
            out.setDaoFactory(daoFactory);
            out.setCoordSystem(chrCS);
            out.setSpecies(species);
        }

        return out;
    }
    
    @Override
    public DAAssembledDNASequence getFragmentByName(String name) throws DAOException {

        if (name==null || name.isEmpty()) {
            return null;
        }

        DAAssembledDNASequence out = null;
        String assName = name;
        CoordinateSystem topCS = null;

        if (singleSpecies) {
            topCS = ssFactory.getDatabase().getTopLevelCoordSystem();
        } else {
            topCS = collFactory.getDatabase().getTopLevelCS(species);
        }

        if (topCS==null || topCS.getId()==null  ) {
            throw new DAOException("Failed to call to retrieve the CoordinateSystem for TopLevel");
        }

        Integer topCSID = topCS.getId();

        HashMap parameters = new HashMap();
        parameters.put("coordSysID", topCSID);

        parameters.put("assName",assName);


        SqlSession session = null;

        try {
            session = this.getFactory().getNewSqlSession();
            ChromosomeMapper mapper = session.getMapper(ChromosomeMapper.class);
            out = mapper.getTopLevelFragmentByName_CoordSysID(parameters);
        } catch (Exception e) {
            throw new DAOException("Failed to call getTopLevelFragmentByName_CoordSysID", e);
        } finally {
            if (session != null) {
                session.close();
            }
        }

        if (out != null) {
            out.setDaoFactory(daoFactory);
            out.setCoordSystem(topCS);
            out.setSpecies(species);
        }

        return out;
    }

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

        List<DAChromosome> out = new ArrayList<DAChromosome>();
        CoordinateSystem chrCS = null;

        if (singleSpecies) {
            chrCS = ssFactory.getDatabase().getChromosomeLevelCoordSystem();
        } else {
            chrCS = collFactory.getDatabase().getChromosomeLevelCS(species);
        }

        if (chrCS==null || chrCS.getId()==null  ) {
            LOGGER.info("Failed to call to retrieve the CoordinateSystem for Chromosomes for: "+species.getShortName());
            return out;
        }

        Integer chrCSID = chrCS.getId();

        HashMap parameters = new HashMap();
        parameters.put("coordSysID", chrCSID);

        SqlSession session = null;

        try {
            session = this.getFactory().getNewSqlSession();
            ChromosomeMapper mapper = session.getMapper(ChromosomeMapper.class);
            out = mapper.getChromosomesByCoordSysID(parameters);
        } catch (Exception e) {
            throw new DAOException("Failed to call getChromsomes", e);
        } finally {
            if (session != null) {
                session.close();
            }
        }
        for (DAChromosome c : out) {
            c.setDaoFactory(daoFactory);
            c.setCoordSystem(chrCS);
            c.setSpecies(species);
        }

        return out;
    }
    
    @Override
    public List<DAAssembledDNASequence> getFragments() throws DAOException {

        List<DAAssembledDNASequence> out = new ArrayList<DAAssembledDNASequence>();
        CoordinateSystem topCS = null;

        if (singleSpecies) {
            topCS = ssFactory.getDatabase().getTopLevelCoordSystem();
        } else {
            topCS = collFactory.getDatabase().getTopLevelCS(species);
        }

        if (topCS==null || topCS.getId()==null  ) {
            LOGGER.info("Failed to call to retrieve the CoordinateSystem for TopLevel for: "+species.getShortName());
            return out;
        }

        Integer topCSID = topCS.getId();

        HashMap parameters = new HashMap();
        parameters.put("coordSysID", topCSID);

        SqlSession session = null;

        try {
            session = this.getFactory().getNewSqlSession();
            ChromosomeMapper mapper = session.getMapper(ChromosomeMapper.class);
            out = mapper.getTopLevelFragmentsByCoordSysID(parameters);
        } catch (Exception e) {
            throw new DAOException("Failed to call getTopLevelFragmentsByCoordSysID", e);
        } finally {
            if (session != null) {
                session.close();
            }
        }
        for (DAAssembledDNASequence c : out) {
            c.setDaoFactory(daoFactory);
            c.setCoordSystem(topCS);
            c.setSpecies(species);
        }

        return out;
    }
    
    @Override
    public DAChromosome getSexLinkedChromosome(Chromosome chr) throws DAOException {
        
        
        if (chr == null || chr.getId()==null || this.getFactory()==null ) {
            throw new DAOException("Invalid call to retrieve sex linked chromosomes");
        }
        
        DAChromosome out = null;
        
        CoordinateSystem chrCS = null;

        if (singleSpecies) {
            chrCS = ssFactory.getDatabase().getChromosomeLevelCoordSystem();
        } else {
            chrCS = collFactory.getDatabase().getChromosomeLevelCS(species);
        }

        if (chrCS==null || chrCS.getId()==null  ) {
            throw new DAOException("Failed to call to retrieve the CoordinateSystem for Chromosomes");
        }

        Integer chrCSID = chrCS.getId();

        HashMap parameters = new HashMap();
        parameters.put("coordSysID", chrCSID);
        parameters.put("seqID", chr.getId());

        SqlSession session = null;

        String name = null;
        try {
            session = this.getFactory().getNewSqlSession();
            ChromosomeMapper mapper = session.getMapper(ChromosomeMapper.class);
            name = mapper.getSexLinkedChromosomeName(parameters);
        } catch (Exception e) {
            throw new DAOException("Failed to call getSexLinkedChromosomeChromsomes", e);
        } finally {
            if (session != null) {
                session.close();
            }
        }

        if (name != null && !name.isEmpty()) {
             out = this.getSpecies().getChromosomeByName(name, chr.getDBVersion());
        } 

        return out;
    }
    
    @Override
    public void setAssemblyExceptions(TreeMap<String, ? extends Chromosome> chrs) throws DAOException {
        
        TreeMap<String, DAChromosome> chromosomes = (TreeMap<String, DAChromosome>) chrs;
        
        if (chromosomes == null || chromosomes.isEmpty() || this.getFactory()==null ) {
            throw new DAOException("Invalid call to retrieve assembly exceptions");
        }

        //Future proofed this to work with multi-speceies collections
        
        Integer speciesID;
        try {
            DAChromosome chr1 = chromosomes.firstEntry().getValue();
            speciesID = this.species.getDBSpeciesID(this.getFactory().getDBVersion());
            if (speciesID==null) {
                throw new Exception();
            }
        } catch (Exception e) {
            throw new DAOException("Invalid call to retrieve assembly exceptions");
        }
        
        
        HashMap parameters = new HashMap();
        parameters.put("speciesID", speciesID);

        List<HashMap> results;
        
        SqlSession session = null;

        try {
            session = this.getFactory().getNewSqlSession();
            ChromosomeMapper mapper = session.getMapper(ChromosomeMapper.class);
            results = mapper.getAssemblyExceptions(parameters);
        } catch (Exception e) {
            throw new DAOException("Failed to call setAssemblyExceptions", e);
        } finally {
            if (session != null) {
                session.close();
            }
        }
        

        AssemblyExceptionRowHandler handler = null;
        
        if (results != null && !results.isEmpty()) {
            handler = new AssemblyExceptionRowHandler(chromosomes, results);
            handler.handleResult();
        }       
               
        for (DAChromosome c:chromosomes.values()) {
            c.setExceptions(true);
        }

    }
        
    //as an inner class it has access to the factory etc of the enclosing class
    public class AssemblyExceptionRowHandler implements DBResultHandler {

        // the magic strings to be used as property keys for HashMap in Ibatis
        protected final String type = "type";
        protected final String target = "target";
        protected final String target_coords = "target_coords";
        protected final String source_coords = "source_coords";
        protected final String targetCSID = "targetCSID";
        protected final String sourceChrName = "sourceChrName";
        protected final String sourceChrID = "sourceChrID";
        
        private TreeMap<String, DAChromosome> chromosomes = null;
        private List<HashMap> rawResults = null;

        public AssemblyExceptionRowHandler(TreeMap<String, DAChromosome> chrs , List<HashMap> results) {
            chromosomes = chrs; 
            rawResults = results;
        }

        @Override
        public List<DAGene> getListResult() {
            return null;
        }

        @Override
        public DAGene getObjectResult() {
            return null;
        }

        public void handleResult() throws DAOException {
            if (chromosomes ==null || chromosomes.isEmpty() 
                    ||rawResults == null || rawResults.isEmpty()) {
                return;
            }
            for (HashMap map : rawResults) {
                handleRow(map);
            }
        }

        private void handleRow(HashMap result) throws DAOException {

            if (result == null || result.isEmpty()) {
                return;
            }
            

            DAChromosome s_sequence = null;
            DADNASequence t_sequence = null;
            String s_name;
            Integer s_id;
            Coordinate s_coords = null;
            Coordinate t_coords = null;
            Integer t_csID = null;
            AssemblyExceptionType ae_type = null;
            
            
            
            s_name = (String) result.get(this.sourceChrName);
            s_id = (Integer) result.get(this.sourceChrID);
            
            s_sequence = this.chromosomes.get(s_name);
            
            if (s_sequence==null || !s_sequence.getId().equals(s_id)) {
                return;
            }
            
            s_coords = (Coordinate) result.get(this.source_coords);

            ae_type = (AssemblyExceptionType) result.get(this.type);   
            if (ae_type == null) {
                ae_type = AssemblyExceptionType.UNKNOWN;
            }
            
            t_coords = (Coordinate) result.get(this.target_coords);
            
            if ( result.get(this.targetCSID) != null ) {
                t_csID = (Integer) result.get(this.targetCSID);
            } else {
                return;
            }
 
            t_sequence = (DADNASequence) result.get(this.target);
            if (t_sequence == null) {
                return;
            }            
            
            CoordinateSystem targetCS  = null;

            if (singleSpecies) {
                    targetCS = ssFactory.getDatabase().getCSByID(t_csID);
               } else {
                    targetCS =collFactory.getDatabase().getCSByID(species, t_csID);
            }

             //we want to convert the DADNASequence to the correct type if it is an assembly!
            
            if (targetCS.isSequenceLevel()) {
                t_sequence.setCoordSystem(targetCS);
            } else if (EnsemblCoordSystemType.chromosome.equals(targetCS.getType())) {
                t_sequence = new DAChromosome((DAOCoreFactory) daoFactory);
                t_sequence.setId(((DADNASequence) result.get(this.target)).getId());
                t_sequence.setName(((DADNASequence) result.get(this.target)).getName());
                t_sequence.setDBSeqLength(((DADNASequence) result.get(this.target)).getDBSeqLength());
                t_sequence.setSpecies(species);
                t_sequence.setCoordSystem(targetCS);
                
                //look to see if we have this sequence in cache
                t_sequence = species.getCachedChromosome((DAChromosome) t_sequence);

            } else {
                t_sequence = new DAAssembledDNASequence((DAOCoreFactory) daoFactory);
                t_sequence.setId(((DADNASequence) result.get(this.target)).getId());
                t_sequence.setName(((DADNASequence) result.get(this.target)).getName());
                t_sequence.setDBSeqLength(((DADNASequence) result.get(this.target)).getDBSeqLength());
                t_sequence.setCoordSystem(targetCS);

                //look to see if we have this sequence in cache
                t_sequence = species.getCachedFragment((DAAssembledDNASequence) t_sequence);
            }
            
            if (t_sequence.getDaoFactory() == null) {
               // pgene.setType(FeatureType.gene);
                t_sequence.setDaoFactory(daoFactory);
            }

            Mapping mapping = new Mapping();
            mapping.setSource(s_sequence);
            mapping.setSourceCoordinates(s_coords);
            mapping.setTarget(t_sequence);
            mapping.setTargetCoordinates(t_coords);
            
            s_sequence.addException(ae_type, mapping);

        }
    }
    
}