/*
 *                    BioJava development code
 *
 * This code may be freely distributed and modified under the
 * terms of the GNU Lesser General Public Licence.  This should
 * be distributed with the code.  If you do not have a copy,
 * see:
 *
 *      http://www.gnu.org/copyleft/lesser.html
 *
 * Copyright for this code is held jointly by the individual
 * authors.  These should be listed in @author doc comments.
 *
 * For more information on the BioJava project and its aims,
 * or to join the biojava-l mailing list, visit the home page
 * at:
 *
 *      http://www.biojava.org/
 *
 */
package org.biojava.nbio.structure.contact;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.vecmath.Point3d;
import javax.vecmath.Vector3d;
import java.io.Serializable;
import java.util.Arrays;


/**
 * A bounding box for short cutting some geometrical calculations.
 *
 * See http://en.wikipedia.org/wiki/Bounding_volume
 *
 * @author Jose Duarte
 *
 */
public class BoundingBox implements Serializable {

        private static final long serialVersionUID = 1L;
        private static final Logger logger = LoggerFactory.getLogger(StructureInterfaceList.class);


        public double xmin;
        public double xmax;
        public double ymin;
        public double ymax;
        public double zmin;
        public double zmax;

        public BoundingBox(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) {
                this.xmin = xmin;
                this.xmax = xmax;
                this.ymin = ymin;
                this.ymax = ymax;
                this.zmin = zmin;
                this.zmax = zmax;
        }

        public BoundingBox(BoundingBox bb) {
                this.xmin = bb.xmin;
                this.xmax = bb.xmax;
                this.ymin = bb.ymin;
                this.ymax = bb.ymax;
                this.zmin = bb.zmin;
                this.zmax = bb.zmax;
        }

        /**
         * Constructs a BoundingBox by calculating maxs and mins of given array of atoms.
         * @param atoms
         */
        public BoundingBox (Point3d[] atoms) {

                if (atoms.length==0) logger.error("Error! Empty list of atoms");

                xmax = atoms[0].x;
                xmin = xmax;
                ymax = atoms[0].y;
                ymin = ymax;
                zmax = atoms[0].z;
                zmin = zmax;

                for(int i=1;i<atoms.length;i++) {
                        if(atoms[i].x > xmax) xmax = atoms[i].x;
                        else if(atoms[i].x < xmin) xmin = atoms[i].x;

                        if(atoms[i].y > ymax) ymax = atoms[i].y;
                        else if(atoms[i].y < ymin) ymin = atoms[i].y;

                        if(atoms[i].z > zmax) zmax = atoms[i].z;
                        else if(atoms[i].z < zmin) zmin = atoms[i].z;
                }

        }


        /** Returns the dimensions of this bounding box.
         *
         * @return a double array (x,y,z) with the dimensions of the box.
         */
        public double[] getDimensions(){

                double[] dim = new double[3];

                dim[0] = xmax-xmin;
                dim[1] = ymax-ymin;
                dim[2] = zmax-zmin;

                return dim;

        }

        /**
         * Given a set of bounding boxes returns a bounding box that bounds all of them.
         * @param boxes
         */
        public BoundingBox(BoundingBox[] boxes) {

                if (boxes.length==0) logger.error("Error! Empty list of bounding boxes");

                xmax = boxes[0].xmax;
                xmin = boxes[0].xmin;
                ymax = boxes[0].ymax;
                ymin = boxes[0].ymin;
                zmax = boxes[0].zmax;
                zmin = boxes[0].zmin;

                for (int i=1;i<boxes.length;i++) {
                        if(boxes[i].xmax > xmax) xmax = boxes[i].xmax;
                        else if(boxes[i].xmin < xmin) xmin = boxes[i].xmin;
                        if(boxes[i].ymax > ymax) ymax = boxes[i].ymax;
                        else if(boxes[i].ymin < ymin) ymin = boxes[i].ymin;
                        if(boxes[i].zmax > zmax) zmax = boxes[i].zmax;
                        else if(boxes[i].zmin < zmin) zmin = boxes[i].zmin;
                }

        }

        private class Bound implements Comparable<Bound> {
                int cardinal;
                double value;
                public Bound(int cardinal,double value) {
                        this.cardinal = cardinal;
                        this.value = value;
                }
                @Override
                public int compareTo(Bound o) {
                        return Double.compare(this.value,o.value);
                }
                @Override
                public String toString() {
                        return "["+cardinal+","+value+"]";
                }
        }

        /**
         * Returns true if this bounding box overlaps given one, i.e. they are within
         * one cutoff distance in one of their 3 dimensions.
         * @param cutoff
         * @return
         */
        public boolean overlaps(BoundingBox o, double cutoff) {
                if (this==o) return true;
                // x dimension
                if (!areOverlapping(xmin,xmax,o.xmin,o.xmax,cutoff)) {
                        return false;
                }
                // y dimension
                if (!areOverlapping(ymin,ymax,o.ymin,o.ymax,cutoff)) {
                        return false;
                }
                // z dimension
                if (!areOverlapping(zmin,zmax,o.zmin,o.zmax,cutoff)) {
                        return false;
                }
                return true;
        }

        private boolean areOverlapping(double imin, double imax, double jmin, double jmax, double cutoff) {

                Bound[] bounds = {new Bound(0,imin), new Bound(1,imax),
                                new Bound(2,jmin), new Bound(3,jmax)};

                Arrays.sort(bounds);

                if ((bounds[0].cardinal==0 && bounds[1].cardinal==1)) {
                        if ((bounds[2].value-bounds[1].value)>cutoff) {
                                return false;
                        }
                } else if (bounds[0].cardinal==2 && bounds[1].cardinal==3) {
                        if ((bounds[2].value-bounds[1].value)>cutoff) {
                                return false;
                        }
                }

                return true;

        }

        /**
         * Check if a given point falls within this box
         * @param atom
         * @return
         */
        public boolean contains(Point3d atom) {
                double x = atom.x;
                double y = atom.y;
                double z = atom.z;
                return xmin <= x && x <= xmax
                                && ymin <= y && y <= ymax
                                && zmin <= z && z <= zmax;
        }

        public void translate(Vector3d translation) {
                xmin+=translation.x;
                xmax+=translation.x;
                ymin+=translation.y;
                ymax+=translation.y;
                zmin+=translation.z;
                zmax+=translation.z;
        }

        /**
         * Returns an array of size 2 with min and max values of given double array
         * @param array
         * @return
         */
        public double[] getMinMax(double[] array) {
                double[] minmax = new double[2];

                double max = Double.MIN_VALUE;
                double min = Double.MAX_VALUE;

                for(double value : array) {
                        if(value > max) max = value;
                        if(value < min) min = value;
                }

                minmax[0] = min;
                minmax[1] = max;
                return minmax;
        }

        @Override
        public String toString() {
                return String.format("[(%7.2f,%7.2f),(%7.2f,%7.2f),(%7.2f,%7.2f)]", xmin,xmax,ymin,ymax,zmin,zmax);
        }
}