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

import java.util.HashMap;
import uk.ac.roslin.ensembl.config.AssemblyExceptionType;
import uk.ac.roslin.ensembl.config.EnsemblCoordSystemType;
import uk.ac.roslin.ensembl.dao.factory.DAOCoreFactory;
import uk.ac.roslin.ensembl.exception.DAOException;
import uk.ac.roslin.ensembl.model.Mapping;
import uk.ac.roslin.ensembl.model.MappingSet;
import uk.ac.roslin.ensembl.model.ObjectType;
import uk.ac.roslin.ensembl.model.core.Chromosome;

/**
 * A DAChromosome is a particular type of DAAssembledDNASequence for representing
 * whole chromosomes.
 * @author paterson
 */
public class DAChromosome extends DAAssembledDNASequence implements Chromosome {

    MappingSet pseudoAutosomalRegion = null;
    DAChromosome parChromosome = null;
    boolean PAR = false;
    HashMap<AssemblyExceptionType, MappingSet> exceptions = null;

    public DAChromosome() {
        super();
    }

    public DAChromosome(DAOCoreFactory factory) {
        super(factory);
    }

    @Override
    public String getChromosomeName() {
        return this.getName();
    }

    @Override
    public void setChromosomeName(String name) {
        this.setName(name);
    }

    @Override
    public String toString() {
        return this.getChromosomeName();
    }

    @Override
    public ObjectType getType() {
        //forces a lazy load so make sure we get CS for all retrieved sequenceIDS in the first query!
        if (this.getCoordSystem() != null) {
            return this.getCoordSystem().getType();
        } else {
            return EnsemblCoordSystemType.chromosome;
        }
    }
    
    @Override
    public MappingSet getPseudoAutosomalRegion() {
        if (!PAR) {
            return null;
        } else if (this.pseudoAutosomalRegion == null) {
            this.setPseudoAutosomalRegion();
        }

        return this.pseudoAutosomalRegion;
    }

    @Override
    public boolean isPAR() {
        return PAR;
    }

    public void setPAR(boolean hasPAR) {
        this.PAR = hasPAR;
    }

    /**
     * Returns the sex-linked 'PAR' chromosome associated with this Chromosome.
     * Null if this chromsome is not flagged as a PAR/Sex-linked chromosome.
     * Triggers lazy loading when not set.
     */
    @Override
    public DAChromosome getParChromosome() {
        if (!PAR) {
            return null;
        }
        if (parChromosome == null && this.getDaoFactory() != null) {
            try {
                parChromosome = (DAChromosome) this.getDaoFactory().getChromosomeDAO().getSexLinkedChromosome(this);
            } catch (DAOException ex) {
            }
        }
        return parChromosome;
    }
    /**

     * private routine to retrieve and set the PAR mappings on this chromosome.
     */
    private void setPseudoAutosomalRegion() {

        parChromosome = this.getParChromosome();

        if (parChromosome != null && this.getDaoFactory() != null) {
            try {
                this.pseudoAutosomalRegion = this.getDaoFactory().getAssemblyDAO().getPARMappingsByStartStop(this, this.getBioBegin(), this.getLength());
            } catch (DAOException ex) {

            }
        }
        
        if (this.pseudoAutosomalRegion==null) {
            this.pseudoAutosomalRegion = new MappingSet();
        }
    }
    
    /**
     * Returns a MappingSet of AssemblyExceptions of the indicated AssemblyExceptionType.
     * Triggers lazy load on this Species to retrieve AssemblyExceptions if necessary.
     * @param type
     * 
     * @throws DAOException 
     */
    public MappingSet getAssemblyExceptions(AssemblyExceptionType type) throws DAOException {
        if (exceptions ==null) {
            //call the lazyload
            this.getSpecies().setAssemblyExceptions(this.getDBVersion());
            if (exceptions ==null) {
                exceptions = new HashMap<AssemblyExceptionType, MappingSet>();
            }
        }
        return (exceptions.get(type)!=null) ? exceptions.get(type) : new MappingSet();
    }
    
    /**
     * Returns whether this chromosome has any AssemblyExceptions.
     * Triggers lazy load on this Species to retrieve AssemblyExceptions if necessary.
     */
    public boolean hasExceptions() {
        if (exceptions !=null && !exceptions.isEmpty()) {
            return true;
        }else{
            try {
                this.getAssemblyExceptions(null);
            } catch (DAOException ex) {
                return false;
            }
            return (!exceptions.isEmpty());
        }
        
    }
    
    /**
     * public method called by the DA infrastructure when adding an
     * AssemblyException mapping of the indicated type.
     * @param type
     * @param mapping 
     */
    public void addException(AssemblyExceptionType type, Mapping mapping) {
        if (exceptions==null) {
            this.setExceptions(true);
        }
        if (!exceptions.containsKey(type)) {
            exceptions.put(type, new MappingSet());
        }
        exceptions.get(type).add(mapping);
    }
    
    /**
     * flag method to create the 'exceptions' HashMap for this chromosome if necessary.
     * @param set 
     */
    public void setExceptions(boolean set) {
        if (exceptions ==null)  {
            this.exceptions = new HashMap<AssemblyExceptionType, MappingSet>();
        }
    }
}