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

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.LinkedHashMap;

/**
 * Information needed to represent a survival curve
 *
 * @author Scooter Willis <willishf at gmail dot com>
 */
public class StrataInfo {

        private ArrayList<Double> time = new ArrayList<Double>();
        private ArrayList<Integer> status = new ArrayList<Integer>();
        private ArrayList<Double> nevent = new ArrayList<Double>();
        private ArrayList<Double> ncens = new ArrayList<Double>();
        private ArrayList<Double> nrisk = new ArrayList<Double>();
        private ArrayList<Double> weight = new ArrayList<Double>();
        private ArrayList<Double> surv = new ArrayList<Double>();
        private ArrayList<Double> varhaz = new ArrayList<Double>();
        private ArrayList<Double> stderr = new ArrayList<Double>();
        private ArrayList<Double> stdlow = new ArrayList<Double>();
        private ArrayList<Double> upper = new ArrayList<Double>();
        private ArrayList<Double> lower = new ArrayList<Double>();
        private LinkedHashMap<Double, Integer> ndead = new LinkedHashMap<Double, Integer>();
        DecimalFormat df = new DecimalFormat("#.######");
        DecimalFormat dfe = new DecimalFormat("0.000000E0");

        /**
         * Need to find the actual time for the nearest time represented as a
         * percentage Would be used to then look up the number at risk at that
         * particular time
         *
         * @param timePercentage
         * @return
         */
        public Double getNearestTime(double timePercentage) {
                //the arrays should be sorted by time so this step is probably not needed
                Double minTime = null;
                Double maxTime = null;
                for (Double t : time) {
                        if (minTime == null || t < minTime) {
                                minTime = t;
                        }
                        if (maxTime == null || t > maxTime) {
                                maxTime = t;
                        }
                }
                Double timeRange = maxTime - minTime;
                Double targetTime = minTime + timePercentage * timeRange;
                Double previousTime = null;
                for (Double t : time) {
                        if (previousTime == null || t <= targetTime) {
                                previousTime = t;
                        } else {
                                return previousTime;
                        }
                }
                return previousTime;
        }

        /**
         * Selection of number of risk will depend on the precision and rounding of
         * time in the survival table. If you are asking for 12 and entry exists for
         * 11.9999999 then 12 is greater than 11.99999 unless you round.
         *
         * @param t
         * @return
         */
        public Double getNearestAtRisk(double t) {
                Integer index = 0;
/*       String timeValue = t + "";
                String format = "#";
                int numDecimals = 0;
                int decimalIndex = timeValue.indexOf(".");
                if (decimalIndex > 0) {
                        for (int i = timeValue.length() - 1; i > decimalIndex; i--) {
                                if (timeValue.charAt(i) == '0' && numDecimals == 0) {
                                        continue;
                                }
                                if (i == decimalIndex - 1) {
                                        format = format + ".#";
                                } else {
                                        format = format + "#";
                                }
                        }
                }
 */
                DecimalFormat newFormat = new DecimalFormat("#.#"); //used to round on expected precision of time. Not correct but trying to match the other packages

                for (int i = 0; i < time.size(); i++) {
                        Double compareTime = time.get(i);
                  //  compareTime = new Double(Math.round(compareTime)); //this is rounding up so that we stop on the first match trying to get this to match another report. Not correct or the other report is wrong
                        compareTime = Double.valueOf(newFormat.format(compareTime));
                        if (compareTime < t) {
                                index = i + 1 ;
                        } else if(compareTime == t){
                                index = i;
                                break;
                        }else {
                                break;
                        }
                }

                //http://www.inside-r.org/packages/cran/rms/docs/survplot
                //per validation using survplot from RMS package and ggkm they select the next
                //time in the future which doesn't seem to be correct as the next time represents
                //knowledge about the future but maybe nrisk at that point in time is defined
                //as the nrisk prior to that time. This appears to be the case where at time 0
                //you would expect that everyone is at risk and you should report that time which
                //is the case in survplot. Added in index = 0 or if the time you are requesting has
                //an exact match
                //survplot(kma,n.risk=TRUE,time.inc=1090)
                //ggkm(kma,timeby=1090)
           //     if(index != 0 && time.get(index) != t){
           //      index++;
           //     }
                if (index >= nrisk.size()) {
                        return null;
                } else {
                        return nrisk.get(index);
                }
        }

        /**
         *
         * @param d
         * @return
         */
        public String f(Double d) {
                String v = df.format(d);
                int l = 10 - v.length();
                for (int i = 0; i < l; i++) {
                        v = v + " ";
                }
                return v;
        }

        @Override
        public String toString() {
                String o = "";
                o = o + "n=" + nevent.size() + "\r\n";
                o = o + "     time      nevent     ncens     nrisk     weight     surv   varhaz    stderr    stdlow    lower    upper\r\n";
                for (int i = 0; i < nevent.size(); i++) {
                        //    if(nevent.get(i) == 0)
                        //        continue;
                        o = o + (i + 1) + "    " + f(time.get(i)) + " " + f(nevent.get(i)) + " " + f(ncens.get(i)) + " " + f(nrisk.get(i)) + " " + f(weight.get(i)) + " " + f(surv.get(i)) + " " + (varhaz.get(i)) + "  " + stderr.get(i) + "  " + stdlow.get(i) + "  " + lower.get(i) + "  " + upper.get(i) + "\r\n";

                }
                o = o + "\r\n";
                //   for(Integer i : ndead.values()){
                //       o = o + i + "\r\n";
                //   }

                return o;
        }

        /**
         * @return the time
         */
        public ArrayList<Double> getTime() {
                return time;
        }

        /**
         * @return the surv
         */
        public ArrayList<Double> getSurv() {
                return surv;
        }

        /**
         * @return the stderr
         */
        public ArrayList<Double> getStderr() {
                return stderr;
        }

        /**
         * @return the upper
         */
        public ArrayList<Double> getUpper() {
                return upper;
        }

        /**
         * @return the lower
         */
        public ArrayList<Double> getLower() {
                return lower;
        }

        /**
         * @return the status
         */
        public ArrayList<Integer> getStatus() {
                return status;
        }

        /**
         * @return the nevent
         */
        public ArrayList<Double> getNevent() {
                return nevent;
        }

        /**
         * @return the ncens
         */
        public ArrayList<Double> getNcens() {
                return ncens;
        }

        /**
         * @return the nrisk
         */
        public ArrayList<Double> getNrisk() {
                return nrisk;
        }

        /**
         * @return the weight
         */
        public ArrayList<Double> getWeight() {
                return weight;
        }

        /**
         * @return the ndead
         */
        public LinkedHashMap<Double, Integer> getNdead() {
                return ndead;
        }

        /**
         * @return the varhaz
         */
        public ArrayList<Double> getVarhaz() {
                return varhaz;
        }

        /**
         * @return the stdlow
         */
        public ArrayList<Double> getStdlow() {
                return stdlow;
        }

        /**
         * @param stdlow the stdlow to set
         */
        public void setStdlow(ArrayList<Double> stdlow) {
                this.stdlow = stdlow;
        }
}