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

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import uk.ac.roslin.ensembl.config.EnsemblCoordSystemType;
import uk.ac.roslin.ensembl.dao.factory.DAOVariationFactory;
import uk.ac.roslin.ensembl.datasourceaware.DAObject;
import uk.ac.roslin.ensembl.exception.NonUniqueException;
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;
import uk.ac.roslin.ensembl.model.variation.Variation;
import uk.ac.roslin.ensembl.model.variation.VariationType;

/**
 *
 * @author tpaterso
 */
public class DAVariation extends DAObject implements Variation {

    final static Logger LOGGER = LoggerFactory.getLogger(DAVariation.class);
    //use the target comparator for these as will have multiple identical source mappings!
    protected MappingSet mappings = new MappingSet(Mapping.mappingOnTargetComparator);
    protected HashMap<ObjectType, MappingSet> objectTypeMappings = new HashMap<ObjectType, MappingSet>();
    protected Set<ObjectType> mappedObjectTypes = new HashSet<ObjectType>();
    protected String name;
    protected String synonym;
    protected List<String> synonyms = new ArrayList<String>();
    protected String ancestralAllele;
    protected DAVariationXRef xref;
    protected VariationType varType;
    protected Boolean somatic = false;
    protected Boolean flipped = false;
    protected int occurrences;
    private Boolean initOK = false;

    public DAVariation() {
        super();
    }

    public DAVariation(DAOVariationFactory factory) {
        super(factory);
    }

    /**
     * This is a hack to classigy the loaded mapping by type, because MyBatis 
     * apparently sets 'mappings' by reflection, not
     * with the setter, so objectTypeMappings is not initialized by the MyBatis call.
     */
    public void checkInitialized() {
        if (!initOK) {
            for (Mapping mapping : mappings) {
                ObjectType t = mapping.getTargetType();

                if (t != null) {
                    if (!this.objectTypeMappings.containsKey(t)) {
                        this.objectTypeMappings.put(t, new MappingSet());
                    }
                    this.objectTypeMappings.get(t).add((Mapping) mapping);
                }
            }
        }
        initOK = true;
    }

    @Override
    public DAOVariationFactory getDaoFactory() {
        return (DAOVariationFactory) daoFactory;
    }

    @Override
    public VariationType getType() {
        return varType;
    }

    public void setVarType(VariationType varType) {
        this.varType = varType;
    }

    @Override
    public void addMappedObjectType(ObjectType mappedType) {
        mappedObjectTypes.add(mappedType);
    }

    @Override
    public Boolean isObjectTypeMapped(ObjectType mappedType) {
        return mappedObjectTypes.contains(mappedType);
    }

    @Override
    public Boolean isCurrent() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    /**
     * Utility method to pull back a single mapping of this Feature on a Given
     * chromosome. This should be the mapping stored at initialisation. If the
     * Feature has implemented a reinitialize method this may be called.
     *
     * @param chr
     * @return a single Mapping
     * @throws NonUniqueException if more than one mapping for the chromosome
     */
    @Override
    public Mapping getChromosomeMapping(Chromosome chr) throws NonUniqueException {

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

        Mapping uniqueMapping = null;

        MappingSet s = this.getLoadedMappings(EnsemblCoordSystemType.chromosome);

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

        boolean found = false;

        for (Mapping m : s) {
            if (m.getTarget() == chr) {
                if (found) {
                    throw new NonUniqueException();
                }
                uniqueMapping = m;
                found = true;
            }
        }
        return uniqueMapping;
    }

    /**
     * Utility method to pull back a unique chromosomal mapping of this Feature.
     * This should be the mapping stored at initialisation. If the Feature has
     * implemented a reinitialize method this may be called.
     *
     * @return a single Mapping
     * @throws NonUniqueException if more than one mapping for the chromosome
     */
    @Override
    public Mapping getChromosomeMapping() throws NonUniqueException {

        Mapping uniqueMapping = null;
        MappingSet s = this.getLoadedMappings(EnsemblCoordSystemType.chromosome);

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

        if (s.size() > 1) {
            throw new NonUniqueException();
        }

        return s.first();
    }

    /**
     * Method to return all chromosomal mappings for this feature. In most
     * circumstances there should be only one mapping. If the Feature has
     * implemented a re-initialize method this may be called.
     *
     * @return MappingSet ordered set of chromosomal mappings
     */
    @Override
    public MappingSet getChromosomeMappings() {

        return this.getLoadedMappings(EnsemblCoordSystemType.chromosome);
    }

    //Should Be Private?? and call by named object type methods ??
    @Override
    public MappingSet getLoadedMappings(ObjectType targetType) {
        this.checkInitialized();
        if (this.objectTypeMappings.containsKey(targetType)) {
            return this.objectTypeMappings.get(targetType);
        } else if (this.isObjectTypeMapped(targetType)) {
            this.objectTypeMappings.put(targetType, new MappingSet());
            return this.objectTypeMappings.get(targetType);
        } else {
            return new MappingSet();
        }
    }

    @Override
    public MappingSet getLoadedMappings() {
        //we haven't got the lazy load working here yet
        return (MappingSet) this.mappings;
    }

    //added for MyBatis - but it fails to use it - sets by reflection instead
    public MappingSet getMappings() {
        //we haven't got the lazy load working here yet
        return (MappingSet) this.mappings;
    }

    @Override
    public Boolean addMapping(Mapping mapping) {
        //if we fail to add the mapping this will be false
        if (this.mappings.add((VariationMapping) mapping)) {

            ObjectType t = mapping.getTargetType();

            if (t != null) {
                if (!this.objectTypeMappings.containsKey(t)) {
                    this.objectTypeMappings.put(t, new MappingSet());
                }

                this.objectTypeMappings.get(t).add((Mapping) mapping);
            }
            return true;
        }

        return false;
    }

    public void setMappings(MappingSet mappings) {
        for (Mapping m : mappings) {
            this.addMapping(m);
        }
        initOK = true;
    }

    @Override
    public void clearAllMappings() {
        mappings.clear();
        mappedObjectTypes.clear();
        objectTypeMappings.clear();
        initOK = false;
    }

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

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

    @Override
    public DAVariationXRef getXRef() {
        return xref;
    }

    public void setXRef(DAVariationXRef xref) {
        this.xref = xref;
    }

    @Override
    public Boolean isSomatic() {
        return this.somatic;
    }

    public void setSomatic(Boolean somatic) {
        this.somatic = somatic;
    }

    @Override
    public Boolean isFlipped() {
        return this.flipped;
    }

    public void setFlipped(Boolean flipped) {
        this.flipped = flipped;
    }

    @Override
    public String getAncestralAllele() {
        return this.ancestralAllele;
    }

    public void setAncestralAllele(String ancestralAllele) {
        this.ancestralAllele = ancestralAllele;
    }

    @Override
    public int getOccurrences() {
        return this.occurrences;
    }

    public void setOccurrences(int count) {
        this.occurrences = count;
    }

    @Override
    public String getSynonym() {
        return this.synonym;
    }

    @Override
    public List<String> getAllSynonyms() {
        return this.synonyms;
    }

    @Override
    public void setSynonym(String altname) {
        this.synonym = altname;
        this.synonyms.add(altname);
    }
}