/**
 * 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.List;
import java.util.HashMap;
import org.apache.ibatis.session.SqlSession;
import uk.ac.roslin.ensembl.biojava3.EnsemblDNASequenceReader;
import uk.ac.roslin.ensembl.dao.coreaccess.DNASequenceDAO;
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.mapper.handler.DBResultHandler;
import uk.ac.roslin.ensembl.mapper.core.SequenceMapper;
import uk.ac.roslin.ensembl.exception.DAOException;
import uk.ac.roslin.ensembl.model.core.DNASequence;
import uk.ac.roslin.ensembl.config.EnsemblCoordSystemType;
import uk.ac.roslin.ensembl.dao.factory.DAOCollectionCoreFactory;
import uk.ac.roslin.ensembl.dao.factory.DAOSingleSpeciesCoreFactory;
import uk.ac.roslin.ensembl.model.core.CoordinateSystem;

/**
 *
 * @author paterson
 */
public class DBDNASequenceDAO extends DBCoreObjectDAO implements DNASequenceDAO{
    
    public DBDNASequenceDAO()  {
        super();
    }

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

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

    @Override
    public String getSequenceByStartStop(EnsemblDNASequenceReader reader, Integer start, Integer stop) throws DAOException {


        if (reader==null || reader.getSeqRegionID()==null) {
            throw new DAOException("Invalid parameter handed to getSequenceByStartStop(EnsemblDNASequenceReader reader, Integer start, Integer stop)");
        }

        String out = null;

        Integer id = reader.getSeqRegionID();
        Integer begin = start;
        Integer end = stop;

        HashMap parameters = new HashMap();
        parameters.put("id", id);

        SqlSession session = null;

        try {
            session = this.getFactory().getNewSqlSession();
            SequenceMapper mapper = session.getMapper(SequenceMapper.class);

            if (stop ==null && start ==null) {
                out = mapper.getSequence(parameters);
            } else if (stop==null && start != null) {
                parameters.put("start", begin);
                out = mapper.getSequenceStart(parameters);
            } else {
                parameters.put("start", begin);
                parameters.put("stop", end);
                out = mapper.getSequenceStartStop(parameters);
            }



        } catch (Exception e) {
            throw new DAOException("Failed to call getSequenceByStartStop", e);
        } finally {
            if (session != null) {
                session.close();
            }
        }

        return out;
    }

   
    @Override
    public String getFullSequence(EnsemblDNASequenceReader reader) throws DAOException {
        return this.getSequenceByStartStop(reader, null, null);
    }

    @Override
    public DADNASequence getSequenceByID(Integer id) throws DAOException {

        if (id==null ) {
            throw new DAOException("Invalid parameter handed to getSequenceByID(Integer id)");
        }

        DADNASequence seq = null;

        HashMap parameters = new HashMap();
        List<HashMap> results = null;
        parameters.put("id", id);

        SequenceRowHandler handler = null;
        SqlSession session = null;

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

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

        handler = new SequenceRowHandler(results);
        handler.handleResult();
        seq = handler.getObjectResult();


        return seq;
    }
    
    @Override
    public DADNASequence getValidatedSequence(DNASequence seq) throws DAOException {

        if (seq==null ||  seq.getId()==null) {
            return null;
        }

       if ( !(seq instanceof DADNASequence) ) {
           throw new DAOException("Illegal attempt to validate a non DA sequence ");
       }

        DADNASequence inseq = (DADNASequence) seq;
        List<HashMap> results = null;

        DADNASequence newSeq = null;

        HashMap parameters = new HashMap();
        parameters.put("id", inseq.getId());

        SequenceRowHandler handler = null;
        SqlSession session = null;

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

        if (results ==null || results.isEmpty()) {
            //this punts back the original sequence - ie it has not been validated
            //so would probably be the wrong behavious
            //return inseq;
            return null;
        }

        handler = new SequenceRowHandler(results);
        handler.handleResult();
        newSeq = handler.getObjectResult();

        if (newSeq==null) {
            //this punts back the original sequence - ie it has not been validated
            //so would probably be the wrong behavious
            //return inseq;
            return null;
        }

        //if object is a DAChromosome, that will be the cached version,
        //so return it
        if (newSeq instanceof DAChromosome) {
            return newSeq;
        }

        //if the objects are same class, re-intitialize the original
        if (inseq.getClass().equals(newSeq.getClass()) ) {

            inseq.setDBSeqLength(newSeq.getDBSeqLength());
            inseq.setCoordSystem(newSeq.getCoordSystem());
            inseq.setName(newSeq.getName());
            inseq.setAttributes(newSeq.getAttributes());
            inseq.setLazyLoaded(true);

            return inseq;
            
        }
        //otherwise retrun the new object
        else {
            //beware may want to copy some data from inseq to newSeq
            return newSeq;
        }


    }


    @Override
    public List<? extends DNASequence> getValidatedSequences(List<? extends DNASequence> in_sequences) throws DAOException {

        List<DADNASequence> out_sequences = new ArrayList<DADNASequence>();

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

        List<HashMap> results = null;
        List<DADNASequence> retrievedSeqs = null;
        List<Integer> outIDs = new ArrayList();

        // make a map of the incoming sequences that are to be validated (that have an id)
        HashMap<Integer, DNASequence> in_idHash = new HashMap<Integer, DNASequence>();
        for (DNASequence s: in_sequences ) {
            if (s.getId()!= null //&& s instanceof DADNASequence
                    ) {
                in_idHash.put(s.getId(), s);
            } 
        }


        //if we dont have any sequences to validate - return empty list
        if (in_idHash.isEmpty() || in_idHash.keySet().isEmpty() ) {
            return out_sequences;
        }

        List<Integer> in_ids = new ArrayList<Integer>() {};

        for (Integer i: in_idHash.keySet()) {
            in_ids.add(i);
        }

        HashMap parameters = new HashMap();
        parameters.put("ids", in_ids);

        SequenceRowHandler handler = null;
        SqlSession session = null;

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

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

        handler = new SequenceRowHandler(results);
        handler.handleResult();
        retrievedSeqs  = handler.getListResult();


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


        for (DADNASequence newSeq : retrievedSeqs) {

            //if object is a DAChromosome, that will be the cached version,
            //so use it
            if (newSeq instanceof DAChromosome) {
                out_sequences.add(newSeq);
                outIDs.add(newSeq.getId());
            }


            else if (in_idHash.get(newSeq.getId()).getClass().equals(newSeq.getClass())) {

                //if the new sequence is just the same type as the original
                //just modify the original and use it in the reretruned List
                in_idHash.get(newSeq.getId()).setDBSeqLength(newSeq.getDBSeqLength());
                in_idHash.get(newSeq.getId()).setCoordSystem(newSeq.getCoordSystem());
                in_idHash.get(newSeq.getId()).setName(newSeq.getName());               
                try {
                    ((DADNASequence)in_idHash.get(newSeq.getId())).setAttributes(newSeq.getAttributes());
                    out_sequences.add((DADNASequence) in_idHash.get(newSeq.getId()));
                    outIDs.add(newSeq.getId());
                } catch (ClassCastException cce) { }
                
            }


            else {

                //if the new sequence is a subclass, use it in the return List
                //beware - we may need to copy other properties fromold to new
                out_sequences.add(newSeq);
                outIDs.add(newSeq.getId());

            }


        }

        // ADD BACK any input sequences that werent pulled back from database
        for (Integer i : in_idHash.keySet()) {
            if (!outIDs.contains(i)) {
                try {
                    out_sequences.add((DADNASequence) in_idHash.get(i));
                    outIDs.add(i);
                } catch (ClassCastException cce) { }
            }
        }

        return out_sequences;

    }




    //***********************************************


    public class SequenceRowHandler implements DBResultHandler {

        // the magic strings to be used as property keys for HashMap in Ibatis
        private final String id = "id";
        private final String name = "name";
        private final String length = "length";
        private final String coordSystemID = "csID";
        private final String attributes = "attributes";
        private List<HashMap> rawResults = null;

        //this may be a subclass according to type
        private DADNASequence objectResult = null;


        private List<DADNASequence> listResult = new ArrayList<DADNASequence>();

        public SequenceRowHandler(List<HashMap> results) {
            rawResults = results;
        }


        @Override
        public List<DADNASequence> getListResult() {
            return listResult;
        }

        @Override
        public DADNASequence getObjectResult() {
            return objectResult;
        }

        public void handleResult() throws DAOException {

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

            for (HashMap map : rawResults) {
                handleRow(map);
            }

        }


        private void handleRow(HashMap result) throws DAOException {


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

            DADNASequence rowSequence = null;

            rowSequence = this.parseResult(result);


            if (rowSequence!= null) {
                this.objectResult = rowSequence;
                this.listResult.add((DADNASequence) rowSequence);
            }

        }


        private DADNASequence parseResult(HashMap result) throws DAOException {

            if (result == null) {
                return null;
            }

            DADNASequence pseq = null;
            Integer length = null;
            Integer id = null;
            Integer pcsID = null;
            String name = null;
            CoordinateSystem cs = null;
            List<HashMap> attribs = null;


            pcsID = (Integer) result.get(this.coordSystemID);
            length = (Integer) result.get(this.length);
            id = (Integer) result.get(this.id);
            name = (String) result.get(this.name);
            attribs = (List<HashMap> ) result.get(this.attributes);


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


            if (cs.getType()==EnsemblCoordSystemType.chromosome ) {
                pseq = new DAChromosome();
            } else if (! cs.isSequenceLevel()) {
                pseq = new DAAssembledDNASequence();
            } else {
                pseq = new DADNASequence();
            }


            pseq.setId(id);
            pseq.setCoordSystem(cs);
            pseq.setDBSeqLength(length);
            pseq.setName(name);
            pseq.setDaoFactory(daoFactory);
            
            if (attribs!=null && !attribs.isEmpty()) {
                HashMap<String,String> temp = new HashMap<String,String>();
                for (HashMap hm: attribs) {
                    temp.put((String) hm.get("key"), (String) hm.get("value"));
                }
                pseq.setAttributes(temp);
            }

            //do check for cached chromosomes here
            if (pseq instanceof DAChromosome)
            {
                pseq = species.getCachedChromosome((DAChromosome)pseq);
            }
            
            //look to see if we have this sequence in cache
            if (pseq instanceof DAAssembledDNASequence)
            {
                pseq = species.getCachedFragment((DAAssembledDNASequence) pseq);
            }
            
            return pseq;


        }
    }

}