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

import java.io.Serializable;
import java.util.Comparator;
import uk.ac.roslin.ensembl.model.core.CoordinateSystem;

/**
 * Used to be abstract
 * @author paterson
 */
public class Mapping implements Serializable {

    protected MappableObject source=null;
    protected MappableObject target=null;
    protected Coordinate sourceCoordinates=null;
    protected Coordinate targetCoordinates=null;
    protected CoordinateSystem sourceCoordSystem=null;
    protected CoordinateSystem targetCoordSystem=null;
    protected Mapping reverseMapping=null;

    public Mapping() {
    }

    public static boolean addReverseMapping(Mapping originalMapping) {
        try {
            //don't add the reverse mapping if we already have it
//            for (Mapping mapping : ((MappingSet) originalMapping.getTarget().getLoadedMappings())) {
//                if (mapping.getTarget().getId().equals(originalMapping.getSource().getId())) {
//                    return;
//                }
//            }

            Mapping reverseMapping = new Mapping();
            reverseMapping.setReverseMapping(originalMapping);

            reverseMapping.setSource(originalMapping.getTarget());
            reverseMapping.setTarget(originalMapping.getSource());

            reverseMapping.setSourceCoordinates(originalMapping.getTargetCoordinates());
            reverseMapping.setTargetCoordinates(originalMapping.getSourceCoordinates());

            reverseMapping.getSource().addMapping(reverseMapping);
            originalMapping.setReverseMapping(reverseMapping);

        } catch (Exception e) {
            return false;
        }
        return true;
    }

    public void setSource(MappableObject source) {
        this.source = source;
    }

    public void setTarget(MappableObject target) {
        this.target = target;
    }

    public MappableObject getSource() {
        return source;
    }

    public MappableObject getTarget() {
        return target;
    }

    public ObjectType getTargetType() {
        return (this.getTarget()!=null) ? this.getTarget().getType() : null;
        }

    public ObjectType getSourceType() {
        return (this.getSource()!=null) ? this.getSource().getType() : null;
        }

    public String getTargetHashID() {
        //make it an empty string if there is no target set
        return (this.getTarget()!=null) ? this.getTarget().getHashID() : "";
    }

    public String getSourceHashID() {
        //make it an empty string if there is no source set
        return (this.getSource()!=null) ? this.getSource().getHashID() : "";
    }

    public Coordinate getSourceCoordinates() {
        return this.sourceCoordinates;
    }

    public Coordinate getTargetCoordinates() {
        return this.targetCoordinates;
    }

    public void setSourceCoordinates(Coordinate coord) {
        this.sourceCoordinates = coord;
    }

    public void setTargetCoordinates(Coordinate coord) {
        this.targetCoordinates = coord;
    }

    /**
     * Sets the source coordinate by creating a new Coordinate object form the given parameters.
     * Note that ZERO and null locations are disallowed and will throw IllegalArgument RuntimeExceptions.
     * @param start
     * @param end
     * @param strand 
     */
    public void setSourceCoordinates(Integer start, Integer end, Coordinate.Strand strand) {
        this.sourceCoordinates = new Coordinate(start, end, strand);
    }
    
    /**
     * Sets the source coordinate by creating a new Coordinate object form the given parameters.
     * Note that ZERO and null locations are disallowed and will throw IllegalArgument RuntimeExceptions.
     * @param start
     * @param end
     * @param strand 
     */
    public void setSourceCoordinates(Integer start, Integer end, Integer strand) {
        this.sourceCoordinates = new Coordinate(start, end, strand);
    }

    /**
     * Sets the target coordinate by creating a new Coordinate object form the given parameters.
     * Note that ZERO and null locations are disallowed and will throw IllegalArgument RuntimeExceptions.
     * @param start
     * @param end
     * @param strand 
     */    
    public void setTargetCoordinates(Integer start, Integer end, Coordinate.Strand strand) {
        this.targetCoordinates = new Coordinate(start, end, strand);
    }
    
    /**
     * Sets the target coordinate by creating a new Coordinate object form the given parameters. 
     * Note that ZERO and null locations are disallowed and will throw IllegalArgument RuntimeExceptions.
     * @param start
     * @param end
     * @param strand 
     */    
    public void setTargetCoordinates(Integer start, Integer end, Integer strand) {
        this.targetCoordinates = new Coordinate(start, end, strand);
    }

    @Override
    public boolean equals(Object mapping) {

        if (this == mapping ) {
            return true;
        }

        //this checks for null too..
        if ( ! (mapping instanceof Mapping )) {
            return false;
        }

        Mapping m = (Mapping) mapping;

        boolean out = true;

        //this checks for identity if source and target are set on both mappings
        //and each pair has the same hashcode
        //the hashcode method will be based on objectID, objectType and probably SpeciesID

        if ( !( !this.getSourceHashID().equals("")
                &&  !m.getSourceHashID().equals("")
                && !this.getTargetHashID().equals("")
                &&  !m.getTargetHashID().equals("")
                && this.getSourceHashID().equals(m.getSourceHashID())
                && this.getTargetHashID().equals(m.getTargetHashID())
                ) ) {
            return false;
        }

        return out;

    }

    @Override
    public int hashCode() {

        return this.getSourceHashID().hashCode()+this.getTargetHashID().hashCode();

    }

    public Mapping getReverseMapping() {
        if (reverseMapping==null) {
            Mapping.addReverseMapping(this);
        }
        return reverseMapping;
    }

    public void setReverseMapping(Mapping reverseMapping) {
        this.reverseMapping = reverseMapping;
    }

    public static final MappingOnSourceComparator mappingOnSourceComparator
            = new MappingOnSourceComparator();

    public static final MappingOnTargetComparator mappingOnTargetComparator
            = new MappingOnTargetComparator();

}

    /**
     * Comparator Class for Mappings, based primarily on their source coordinates.
     * This will sort a set of Mappings on the order of the source coordinates
     * or failing that on the ids on the target object, then source object. Beware
     * that this comparison doesn't match the equals logic.
     * @author tpaterso
     */
     class MappingOnSourceComparator implements Comparator<Mapping>, Serializable {
        public int compare(Mapping o1, Mapping o2) {
            // this would only sort mappings with non identical source coordinates
            // however we want to sort multiple things with the same source coordinates if they are different things!
            //return o1.getSourceCoordinates().compareTo(o2.getSourceCoordinates());

            if (o1==null) {
                if (o2 == null) {
                    return 0;
                } else {
                    return -1;
                }
            } else if (o2==null) {
                return +1;
            }

            int out;

            if (o1.getSourceCoordinates()==null) {
                if (o2.getSourceCoordinates()== null) {
                    out=0;
                } else {
                    return -1;
                }
            } else if (o2.getSourceCoordinates()== null) {
                return +1;
            }  else {
                out = o1.getSourceCoordinates().compareTo(o2.getSourceCoordinates());
            }

            if (out != 0) {
                return out;
            } else {

                //if both pairs of hashIDs are same this could break the contract of equals
                //for the set - however it could happen cos the mappings are mutable
                if (o1.getTargetHashID().equals(o2.getTargetHashID()) &&
                        o1.getSourceHashID().equals(o2.getSourceHashID())  ) {
                    //it looks like the mappings really are for the same things!
                    //so return this
                    return 0;
                } else {

                    //not the same
                    out = -1;

                    try {
                        //try to order them by the Target's ID number
                        out = o1.getTargetHashID().compareTo(o2.getTargetHashID());
                        // but if they have the same ID ignore this
                        if (out == 0) {
                            out = o1.getSourceHashID().compareTo(o2.getSourceHashID());
                        }
                        // but if these also have the same ID ignore this and return a random ordering
                        if (out == 0) {
                            out = -1;
                        }
                    } catch (Exception e) {
                    }
                    return out;
                }
            }
        }
    }

    /**
     * Comparator Class for Mappings, based primarily on their target coordinates.
     * This will sort a set of Mappings on the order of the target coordinates
     * or failing that on the ids on the source object, then target object. Beware
     * that this comparison doesn't match the equals logic.
     * @author tpaterso
     */
     class MappingOnTargetComparator implements Comparator<Mapping>, Serializable {
        public int compare(Mapping o1, Mapping o2) {
            // this would only sort mappings with non identical source coordinates
            // however we want to sort multiple things with the same source coordinates if they are different things!
            //return o1.getSourceCoordinates().compareTo(o2.getSourceCoordinates());

            if (o1==null) {
                if (o2 == null) {
                    return 0;
                } else {
                    return -1;
                }
            } else if (o2==null) {
                return +1;
            }

            int out;

            if (o1.getTargetCoordinates()==null) {
                if (o2.getTargetCoordinates()== null) {
                    out=0;
                } else {
                    return -1;
                }
            } else if (o2.getTargetCoordinates()== null) {
                return +1;
            }  else {
                out = o1.getTargetCoordinates().compareTo(o2.getTargetCoordinates());
            }

            if (out != 0) {
                return out;
            } else {

                //if both pairs of hashIDs are same this could break the contract of equals
                //for the set - however it could happen cos the mappings are mutable
                if (o1.getTargetHashID().equals(o2.getTargetHashID()) &&
                        o1.getSourceHashID().equals(o2.getSourceHashID())  ) {
                    //it looks like the mappings really are for the same things!
                    //so return this
                    return 0;
                } else {

                    //not the same
                    out = -1;

                    try {
                        //try to order them by the Target's ID number
                        out = o1.getSourceHashID().compareTo(o2.getSourceHashID());
                        // but if they have the same ID ignore this
                        if (out == 0) {
                            out = o1.getTargetHashID().compareTo(o2.getTargetHashID());
                        }
                        // but if these also have the same ID ignore this and return a random ordering
                        if (out == 0) {
                            out = -1;
                        }
                    } catch (Exception e) {
                    }
                    return out;
                }
            }
        }
    }