/**
 * 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 org.apache.ibatis.session.SqlSession;
import uk.ac.roslin.ensembl.model.Mapping;
import uk.ac.roslin.ensembl.model.MappingSet;
import uk.ac.roslin.ensembl.dao.coreaccess.AssemblyDAO;
import uk.ac.roslin.ensembl.datasourceaware.core.DAAssembledDNASequence;
import uk.ac.roslin.ensembl.datasourceaware.core.DADNASequence;
import uk.ac.roslin.ensembl.dao.factory.DAOCollectionCoreFactory;
import uk.ac.roslin.ensembl.dao.factory.DAOSingleSpeciesCoreFactory;
import uk.ac.roslin.ensembl.datasourceaware.core.DAChromosome;
import uk.ac.roslin.ensembl.mapper.core.SequenceMapper;
import uk.ac.roslin.ensembl.exception.DAOException;
import uk.ac.roslin.ensembl.mapper.handler.DBResultHandler;
import uk.ac.roslin.ensembl.model.Coordinate;
import uk.ac.roslin.ensembl.model.core.Chromosome;
import uk.ac.roslin.ensembl.model.core.CoordinateSystem;
import uk.ac.roslin.ensembl.model.core.DNASequence;

/**
 *
 * @author paterson
 */
public class DBAssemblyDAO extends DBCoreObjectDAO implements AssemblyDAO {

    public DBAssemblyDAO() {
        super();
    }

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

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

    @Override
    public MappingSet getComponentMappingsByStartStop(DNASequence assembledSequence, Integer begin, Integer stop) throws DAOException {


        if (assembledSequence == null || begin == null || stop == null
                || assembledSequence.getId() == null
                || assembledSequence.getCoordSystem() == null
                || assembledSequence.getCoordSystem().getId() == null) {
            throw new DAOException("Invalid parameters passed to getComponentMappingsByStartStopDNASequence assembledSequence, Integer begin, Integer stop ");
        }

        MappingSet componentMappings = new MappingSet();
        List<Mapping> results;
        DAAssembledDNASequence parent;
        SqlSession session = null;

        try {
            parent = (DAAssembledDNASequence) assembledSequence;
        } catch (ClassCastException e) {
            throw new DAOException("This sequence is not an assembly!");
        }

        Integer start = begin;
        Integer end = stop;
        CoordinateSystem seqLevelCS = null;

        Integer seqLevelCoordSysID = null;
        Integer parentCoordSysID = null;

        try {
            if (singleSpecies) {
                seqLevelCS = ssFactory.getDatabase().getSequenceLevelCoordSystem();
            } else {
                seqLevelCS = collFactory.getDatabase().getSequenceLevelCS(species);
            }

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

            seqLevelCoordSysID = seqLevelCS.getId();
            parentCoordSysID = parent.getCoordSystem().getId();

            if (seqLevelCoordSysID.equals(parentCoordSysID)) {
                //the parent is at sequence level - so dont need a projection
                //probably prevent this call happening before here
                throw new DAOException("This sequence is not an assembly!");
            }

            Integer seqRegionID = parent.getId();

            //none of these should be null

            HashMap parameters = new HashMap();
            parameters.put("seqRegionID", seqRegionID);
            parameters.put("start", start);
            parameters.put("end", end);
            parameters.put("seqLevelCoordSysID", seqLevelCoordSysID);

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

            //this first call just gets sequence levelmappings

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

        if (results == null || results.isEmpty()) {
            try {

                Integer seqRegionID = parent.getId();

                //none of these should be null

                HashMap parameters = new HashMap();
                parameters.put("seqRegionID", seqRegionID);
                parameters.put("start", start);
                parameters.put("end", end);
                // dont put the sequencelevel CS in as a parameter

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

                //this second call gets every level of mappings

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

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

        // System.out.println("query results: "+results.size());
        //int count = 1;

        if (results != null) {
            for (Mapping mapping : results) {

                mapping.setSource(parent);

                //if the target sequence is not se4quence level we need to change it to
                // an assembledSequence

                DADNASequence seq = (DADNASequence) mapping.getTarget();

                if (!seq.getCsID().equals(seqLevelCoordSysID)) {

                    DAAssembledDNASequence newseq = new DAAssembledDNASequence();
                    newseq.setId(seq.getId());
                    newseq.setName(seq.getName());
                    newseq.setDBSeqLength(seq.getDBSeqLength());
                    newseq.setDaoFactory(daoFactory);

                    //not adding the Reader cos not at sequence level

                    newseq.setCsID(seq.getCsID());
                    if (singleSpecies) {
                        newseq.setCoordSystem(ssFactory.getDatabase().getCSByID(seq.getCsID()));
                    } else {
                        newseq.setCoordSystem(collFactory.getDatabase().getCSByID(species, seq.getCsID()));
                    }
                    
                    //switch
                    mapping.setTarget(newseq);

                } else {
                    //everything returned from this query is a sequence level component
                    seq.setDaoFactory(daoFactory);
                    ((DADNASequence) mapping.getTarget()).setCoordSystem(seqLevelCS);
                    //this is now done by mybatis
                    //((DADNASequence) mapping.getTarget()).setSequenceStorage(mapping.getReader());                  
                }

                //this adds the reverse mapping to the DA DNASequence -
                //not sure if this is required, or if better stored as another type of relationship

                if (componentMappings.add(mapping)) {
                    Mapping.addReverseMapping(mapping);
                }
            }
        }


        return componentMappings;

    }

    @Override
    public MappingSet getPARMappingsByStartStop(Chromosome chr, Integer begin, Integer stop) throws DAOException {

        if (chr == null || !chr.isPAR() || chr.getId() == null
                || chr.getCoordSystem() == null
                || chr.getCoordSystem().getId() == null) {
            throw new DAOException("Invalid chromosome for getPARMappingsByStartStop");
        }

        DAChromosome ychr = (DAChromosome) chr;
        //i need to get the linked chromsome ( ie X if we are mapping Y)        
        DAChromosome xchr = ychr.getParChromosome();

        if (xchr == null) {
            throw new DAOException("No PAR chromosome found for getPARMappingsByStartStop");
        }




        Integer start = begin != null ? begin : ychr.getBioBegin();
        Integer end = stop != null ? stop : ychr.getBioEnd();


        MappingSet parMappings = new MappingSet();
        List<HashMap> results;
        DAAssembledDNASequence parent;
        SqlSession session = null;
        PARMappingHandler handler = null;


        CoordinateSystem chrLevelCS = null;

        try {
            if (singleSpecies) {

                //PARs are mapped at the chromosome level

                chrLevelCS = ssFactory.getDatabase().getChromosomeLevelCoordSystem();
            } else {
                chrLevelCS = collFactory.getDatabase().getSequenceLevelCS(species);
            }

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

            Integer chrLevelCoordSysID = chrLevelCS.getId();
            Integer parentCoordSysID = ychr.getCoordSystem().getId();

            Integer seqRegionID = ychr.getId();

            //none of these should be null

            HashMap parameters = new HashMap();
            parameters.put("seqRegionID", seqRegionID);
            parameters.put("start", start);
            parameters.put("end", end);
            parameters.put("parentCoordSysID", parentCoordSysID);
            parameters.put("chrLevelCoordSysID", chrLevelCoordSysID);

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

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

        if (results != null && !results.isEmpty()) {

            handler = new PARMappingHandler(results, ychr, xchr);
            handler.handleResult();
            parMappings.addAll(handler.getListResult());
        }

        return parMappings;

    }

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

        // the magic strings to be used as property keys for HashMap in Ibatis
        private final String componentID = "componentID";
        private final String targetCoordinates = "targetCoordinates";
        private final String sourceCoordinates = "sourceCoordinates";
        private Mapping objectResult = null;
        private List<Mapping> listResult = new ArrayList<Mapping>();
        private List<HashMap> rawResults = null;
        private DAChromosome sourceChr = null;
        private DAChromosome targetChr = null;
        private int targetID = 0;

        public PARMappingHandler(List<HashMap> results, DAChromosome source, DAChromosome target) {
            sourceChr = source;
            targetChr = target;
            rawResults = results;

            targetID = targetChr.getId();

        }

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

        @Override
        public Mapping 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 {

            Mapping rowMapping = null;

            rowMapping = this.parseResult(result);


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


        }

        private Mapping parseResult(HashMap result) throws DAOException {

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


            Coordinate sCoords = null;
            Coordinate tCoords = null;
            Integer tID = null;


            tID = (Integer) result.get(this.componentID);
            sCoords = (Coordinate) result.get(this.sourceCoordinates);
            tCoords = (Coordinate) result.get(this.targetCoordinates);


            if (tID != this.targetID
                    || sCoords == null
                    || tCoords == null) {
                return null;
            }


            Mapping mapping = new Mapping();
            mapping.setSource(this.sourceChr);
            mapping.setSourceCoordinates(sCoords);
            mapping.setTarget(this.targetChr);
            mapping.setTargetCoordinates(tCoords);



            if (this.sourceChr.addMapping(mapping)) {
                Mapping.addReverseMapping(mapping);
            }

            return mapping;


        }
    }
}