/**
 * Copyright (c) 2011, The University of Southampton and the individual contributors.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 *   *  Redistributions of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 *
 *   *  Redistributions in binary form must reproduce the above copyright notice,
 *      this list of conditions and the following disclaimer in the documentation
 *      and/or other materials provided with the distribution.
 *
 *   *  Neither the name of the University of Southampton nor the names of its
 *      contributors may be used to endorse or promote products derived from this
 *      software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.openimaj.ml.clustering.kdtree;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.log4j.Logger;
import org.openimaj.ml.clustering.kdtree.ClusterTestDataLoader.TestStats;

/**
 * Load clusters from http://people.cs.nctu.edu.tw/~rsliang/dbscan/testdatagen.html
 * @author Sina Samangooei (ss@ecs.soton.ac.uk)
 *
 */
public class ClusterTestDataLoader{
        /**
         * Test details
         * @author Sina Samangooei (ss@ecs.soton.ac.uk)
         *
         */
        public static class TestStats{
                /**
                 * EPS variable
                 */
                public double eps;
                /**
                 * minpts variable
                 */
                public int minpts;
                /**
                 * nclusters variable
                 */
                public int ncluster;
                /**
                 * noutliers variable
                 */
                public int noutliers;
                /**
                 * mineps variable
                 */
                public double mineps;
        }
        private int percluster = -1;
        private boolean outliers = true;
        
        
        /**
         * 
         */
        public ClusterTestDataLoader() {
                this.percluster = -1;
        }
        
        /**
         * @param percluster 
         * @param outliers 
         * 
         */
        public ClusterTestDataLoader(int percluster, boolean outliers) {
                this.percluster = percluster;
                this.outliers = outliers;
        }

        private Logger logger = Logger.getLogger(ClusterTestDataLoader.class);
        private TestStats testStats;
        private int[][] testClusters;
        private double[][] testData;
        /**
         * @param data
         * @return read {@link TestStats}
         */
        private TestStats readTestStats(String[] data) {
                ClusterTestDataLoader.TestStats ret = new TestStats();
                int i = 0;
                ret.eps = Double.parseDouble(data[i++].split("=")[1].trim());
                ret.minpts = Integer.parseInt(data[i++].split("=")[1].trim());
                ret.ncluster = Integer.parseInt(data[i++].split("=")[1].trim());
                ret.noutliers = Integer.parseInt(data[i++].split("=")[1].trim());
                ret.mineps = Double.parseDouble(data[i++].split("=")[1].trim());
                return ret;
        }


        /**
         * @param data
         * @return read the correct clusters
         */
        private int[][] readTestClusters(String[] data) {
                int i = 0;
                for (;data[i].length()!=0; i++);
                for (i=i+1;data[i].length()!=0; i++);
                List<int[]> clusters = new ArrayList<int[]>();
                int count = 0;
                for (i=i+1;i<data.length; i++){
                        int[] readIntDataLine = readIntDataLine(data[i]);
                        clusters.add(readIntDataLine);
                        count += readIntDataLine.length;
                }
                logger .debug(String.format("Loading %d items in %d clusters\n",count,clusters.size()));
                return clusters.toArray(new int[clusters.size()][]);
        }
        

        /**
         * @param string
         * @return read
         */
        public int[] readIntDataLine(String string) {
                String[] split = string.split(",");
                int[] arr = new int[split.length-1];
                int i = 0;

                for (String s : split) {
                        if(s.contains("<"))continue; // skip the first, it is the cluster index
                        s = s.replace(">", "").trim();
                        arr[i++] = Integer.parseInt(s)-1;

                }
                return arr;
        }
        /**
         * @param data
         * @return read the test data
         */
        private double[][] readTestData(String[] data) {
                
                int i = 0;
                for (;data[i].length()!=0; i++);
                List<double[]> dataL = new ArrayList<double[]>();
                int start = i+1;
                for (i=start;data[i].length()!=0; i++){
                        dataL.add(readDataLine(data[i]));
                }
                logger.debug(String.format("Loading %d data items\n",dataL.size()));
                return dataL.toArray(new double[dataL.size()][]);
        }
        private Set<Integer> existing(int[][] correct) {
                Set<Integer> exist = new HashSet<Integer>();
                for (int[] is : correct) {
                        for (int i : is) {
                                exist.add(i);
                        }
                }
                return exist;
        }

        private double[] readDataLine(String string) {
                String[] split = string.split(" ");
                double[] arr = new double[]{
                                Double.parseDouble(split[1]),
                                Double.parseDouble(split[2])
                };
                return arr;
        }

        public void prepare(String[] data) {
                this.testStats = this.readTestStats(data);
                this.testClusters = this.readTestClusters(data);
                this.testData = this.readTestData(data);
                correctClusters();
        }

        private void correctClusters() {
                
                if(this.percluster != -1){
                        double[][] correctedData = null;
                        int[][] correctedClusters = new int[this.testClusters.length][this.percluster]; 
                        int seen ;
                        if(this.outliers){
                                seen = this.testStats.noutliers;
                                correctedData= new double[this.percluster * this.testClusters.length + seen][];
                                for (int i = 0; i < seen; i++) {
                                        correctedData[i] = this.testData[i];
                                }
                                
                        }
                        else{
                                seen = 0;
                                correctedData = new double[this.percluster * this.testClusters.length][];
                        }
                        for (int i = 0; i < this.testClusters.length; i++) {
                                int[] clust = this.testClusters[i];
                                for (int j = 0; j < this.percluster; j++) {
                                        int d = clust[j];
                                        correctedData[seen] = this.testData[d];
                                        correctedClusters[i][j] = seen;
                                        seen++;
                                }
                        }
                        
                        this.testClusters = correctedClusters;
                        this.testData = correctedData;
                }
        }

        public TestStats getTestStats() {
                return this.testStats;
        }

        public double[][] getTestData() {
                return this.testData;
        }

        public int[][] getTestClusters() {
                return this.testClusters;
        }
}