/**
 * 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
 */
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package uk.ac.roslin.ensembl.demo;

import java.util.*;
import uk.ac.roslin.ensembl.config.AssemblyExceptionType;
import uk.ac.roslin.ensembl.config.DBConnection;
import uk.ac.roslin.ensembl.config.EnsemblDBType;
import uk.ac.roslin.ensembl.dao.database.*;
import uk.ac.roslin.ensembl.datasourceaware.compara.DAHomologyPairRelationship;
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.model.Coordinate;
import uk.ac.roslin.ensembl.model.Mapping;
import uk.ac.roslin.ensembl.model.MappingSet;
import uk.ac.roslin.ensembl.model.variation.Variation;

/**
 *
 * @author tpaterso
 */
public class LogicFromArkMAP {

    /*
     * ArkMAP is a downloadable map drawing application the uses the JEnsembl API 
     * to download gene-annotated chromosome maps from Ensembl datasources. 
     * The application integrates JEnsembl data retrieval with ArkDB map drawing 
     * code which uses the Java Swing API. Salient features of Ensembl data retrieval 
     * are combined in this demonstration code (Getting a basic Ensembl map, 
     * Getting gene homologies, Getting SNP variations on an Ensembl map, 
     * Finding regions of conserved synteny for a selected chromosomal region, 
     * Displaying maps of assembly exceptions and haplotypes.)
     */
    public static void main(String[] args) throws Exception {

        // **************** GETTING A BASIC ENSEMBL MAP ********************* //

        //the user selects which source to use
        // from DataSource.ENSEMBLDB,DataSource.ENSEMBLGENOMES or DataSource.ENSEMBLBACTERIA
        DBConnection.DataSource source = DBConnection.DataSource.ENSEMBLDB;

        // a registry is made ( and cached in the App )
        DBRegistry registry = DBRegistry.createRegistryForDataSource(source);

        //the collection of available species is used as the basis for a user selection widget
        Collection<DBSpecies> species = registry.getSpecies();

        //if we have chosen to work with DataSource.ENSEMBLBACTERIA
        // instead we do 
        //Collection<? extends DBSpecies> species = registry.getCollectionSpecies();

        // the chosen species is actually selected from the list
        DBSpecies currentSpecies = registry.getSpeciesByAlias("human");


        //the list of available core databases is used for a release/version selection widget
        // actually the widget is built using a sorted collection of strings representing build/version details
        TreeSet<? extends DBDatabase> dbs;
        if (currentSpecies instanceof DBCollectionSpecies) {
            dbs = currentSpecies.getDatabasesByType(EnsemblDBType.collection_core);
        } else {
            dbs = currentSpecies.getDatabasesByType(EnsemblDBType.core);
        }


        //again the database (i.e. version) is actually selected by the user, here we just get one from the registry
        DBDatabase currentDB = registry.getDatabase("human", EnsemblDBType.core, "72");

        //or for bacteria..
        //DBDatabase currentDB = registry.getDatabase("Bacillus pumilus (strain SAFR-032)", EnsemblDBType.collection_corecore, "14");

        //the list of chromosomes for that species is retireved and used as the basis of a selection widget
        TreeMap<String, DAChromosome> chromosomes = new TreeMap<String, DAChromosome>();

        List<DAChromosome> temp = null;
        if (currentDB instanceof DBSingleSpeciesCoreDatabase) {
            temp = ((DBSingleSpeciesCoreDatabase) currentDB).getChromosomes();
        } else {
            temp = ((DBCollectionCoreDatabase) currentDB).getChromosomes(currentSpecies);
        }
        for (DAChromosome c : temp) {
            chromosomes.put(c.getChromosomeName(), c);
        }

        //the user selects a chromosome
        DAChromosome currentChromosome = chromosomes.get("3");
        //in ArkMAP the user can specify to look at particular coordinates
        //this is not used to retrieve partial chromosomes map
        // but does limit the extent of the chromosome searched for genes
        //genes = chr.getGenesOnRegion(requestStart, requestStop);

        //note that aswell as the genes - we also get Exceptions to show on the map

        //if this is a real chromosome we actually load all the genes
        //but if we are just creating a map of an assembly exception here we would restrict this
        //to the extent of the patch
        int start = currentChromosome.getBioBegin();
        int stop = currentChromosome.getBioEnd();

        //force the lazy load the genes
        List<DAGene> genesOnRegion = currentChromosome.getGenesOnRegion(start, stop);
        //force the lazy load all types of exeptions
        currentChromosome.getAssemblyExceptions(AssemblyExceptionType.PATCH_FIX);

        // the chromosome is then used to make a map - which is zoomed to the specified coordinates for display
        //EnsemblMap map = new EnsemblMap( currentChromosome, start, stop );

        // the map is made by creating an EnsemblMapping object for each gene mapping on the chromosome
        // and making an EnsemblExceptionMapping for each AssemblException mapped on the chromosome
         
        /*
        *
        public EnsemblMap(DAChromosome _chr) throws DAOException {

            this.chr = _chr;
            this.start = chr.getBioBegin();
            this.stop = chr.getBioEnd();

            try {
                this.setAnalysis(Analyses.getAnalysis(this.chr.getDaoFactory().getDatabase()));
            } catch (Exception e) {}

            mapName =
                    this.chr.getSpecies().getSpeciesBinomial() + " ("
                    + this.chr.getSpecies().getShortName() + ")" + " chromosome "
                    + this.chr.getChromosomeName(); 

            //these must already be loaded 
            for (Mapping m : this.getEnsemblChr().getLoadedMappings(FeatureType.gene)) {
            addEnsemblMapping(m);
            }
            for (AssemblyExceptionType t : AssemblyExceptionType.values()) {
                if (!t.equals(AssemblyExceptionType.PAR)) {
                    for (Mapping m : this.getEnsemblChr().getAssemblyExceptions(t)) {
                        addEnsemblExceptionMapping(m, t);
                    }
                }
            }
        }
        * 
        */
        
        // ***************** GETTING GENE HOMOLOGIES ************************ //
        
        //if the user selects an Ensembl gene on a Map
        //they can search for homologies -  on alll species or just a selected species
        //these results are shown in a table 
        List<DAHomologyPairRelationship> homologies;
        DBSpecies selectedSpecies = null;
        DAGene selectedGene = currentSpecies.getGeneByStableID("ENSG00000153551", "72");


        try {
            if (selectedSpecies != null) {
                homologies = selectedGene.getHomologies(selectedSpecies);
                //note that this actually does a query to get all the homologies and then filters the result
                //so is no faster than below
            } else {
                homologies = selectedGene.getHomologies();
            }
        } catch (Exception e) {
            System.out.println("Error in thread to get homologues of a Gene Ensembl DataSource: " + e.toString());
        }
        
        
        
        // ************* GETTING SNP VARIATIONS ON AN ENSEMBL MAP *********** //
        Coordinate zoomCoord = new Coordinate(32900000, 33000000);


        try {

            List<? extends Variation> vars = currentChromosome.getVariationsOnRegion(zoomCoord);

            if (vars == null || vars.isEmpty()) {
                throw new Exception("No Variations found on " + currentChromosome.getSpecies().getCommonName()
                        + " chromosome " + currentChromosome.getChromosomeName() + " (release " + currentChromosome.getDBVersion() + ")");
            }

            //the App makes a new map  - as above for this region of the chromosome
            //EnsemblMap map = new EnsemblMap(currentChromosome, zoomCoord.getStart(), zoomCoord.getEnd());

            //we then make ArkDB API objects for the Marker and the Mapping and 
            //add these to the EnsemblMap object
            for (Variation v : vars) {

                Mapping mp = (Mapping) v.getLoadedMappings().first();
                Coordinate coord = mp.getTargetCoordinates();

                //ArkDB code
                /*
                 * 
                    DatasourceAwareMarker mkr = new DatasourceAwareMarker();
                    mkr.setDbsnpID(v.getName());
                    mkr.setAccession(v.getId().toString());     
                    mkr.setMarkerType("SNP");   
                 * 
                 */
                
                // if the variation has a 'synonym' set - this equals the search name, and there is a different 'name'
                // if the 'synonym' is not set, the search name = 'name'

                //we have a synonym
                if (v.getSynonym() != null && !v.getSynonym().isEmpty()) {
                    //ArkDB code
                    //mkr.setName(v.getSynonym()); 
                } else {
                    //ArkDB code
                    //mkr.setName(v.getName());
                }

                //ArkDB code
//                    DatasourceAwareMapping mpp = new DatasourceAwareMapping();
//                    mpp.setMarker(mkr);

                double begin = coord.getStart().doubleValue();
                double end = coord.getEnd().doubleValue();

                if (end < begin) {
                    double d = end;
                    end = begin;
                    begin = d;
                }
                //ArkDB code
//                    mpp.setMarkerStart(begin);
//                    mpp.setMarkerEnd(end);
//                    mpp.setMarkerMiddle(begin + (end-begin)/2 );
//                    mpp.setMap(map);

                //ArkMAP code - we add each mapping to the map
//                    map.addMapping(mpp);
//                    snpMappings.add(mpp);

            }

        } catch (Exception e) {
        }

        // *************** FIND REGIONS OF CONSERVED SYNTENY ******************//
        // *************** FOR A SELECTED REGION OF A CHROMOSOME *************//

        //ArrayList<EnsemblMap> maps = new ArrayList<EnsemblMap>();

        HashMap<DADNASequence, MappingSet> syntenies;
        Coordinate searchCoord = new Coordinate(30000000, 35000000);
        selectedSpecies = registry.getSpeciesByAlias("chimp");


        try {

            syntenies = currentChromosome.getRegionsOfConservedSynteny(searchCoord, selectedSpecies);

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

                for (DADNASequence seq : syntenies.keySet()) {
                    if (seq instanceof DAChromosome) {
                        Coordinate coords = syntenies.get(seq).getExtent();


                        // making a map of the whole chromsome  
                        //- but just going to initially display the bit with conserved synteny
                        //EnsemblMap map = new EnsemblMap((DAChromosome) seq);

                        //we then pass the map back together with the Coordinates to display
                        // the chromosome is searched for genes and exceptions before
                        //display

                    }
                }
            }
        } catch (Exception e) {
            System.out.println("Error in thread to get syntenic regions: " + e.toString());
        }
        
        
    // ************ DISPLAY THE MAP OF AN ASSEMBLY EXCEPTION *************//
        
    //ArkMAP displays the position of Assembly Exceptions on the EnsemblMaps as 
    //special 'EnsemblExceptionMappings' .
    //These  are colour coded depending on the type of exception (e.g for Human v68 
    //chromosome 17 there are AssemblyPatches, AssemblyNovel and Haplotypes 
    //displayed)
    //if a user selects a Marker that is an AssemblyException  
    //they get the option to display this Exception as a new map
        
    DAChromosome patchChromosome = null;
    Coordinate patchCoordinates = null;

    /*
     * 
      if (mapping instanceof EnsemblMappingView ) { 
          EnsemblMapping ming = ((EnsemblMappingView) mapping).getMapping(); 
          if (ming instanceof EnsemblExceptionMapping) { 
                EnsemblExceptionMapping exMapping = (EnsemblExceptionMapping) ming; 
                patchChromosome = exMapping.getPatchChromosome(); 
                patchCoordinates = exMapping.getPatchChromosomeCoordinates(); } }
     *
     */
    
    //only the region of the patch/exception is real sequence, so we only display this region,
    //and we only fetch the genes on this region by lazy load
    
    /*
    patchChromosome.getGenesOnRegion (patchCoordinates.getStart(), patchCoordinates.getEnd());
    */
    
    //redundant here..
    /*
    patchChromosome.getAssemblyExceptions (AssemblyExceptionType.PATCH_FIX);
    */
    
    //Make the new map for display
    //EnsemblMap map = new EnsemblMap( patchChromosome, patchCoordinates.getStart(), patchCoordinates.getStart() );

    
    
    }
}