package main;

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.Random;

import javafx.scene.image.Image;
import javafx.scene.image.WritablePixelFormat;

public class Main {

    private class Color {
        private double r;
        private double g;
        private double b;

        public Color(double r_, double g_, double b_) {
            r = r_;
            g = g_;
            b = b_;
        }

        public double getR() {
            return r;
        }

        public double getG() {
            return g;
        }

        public double getB() {
            return b;
        }

        public double euclidean(Color c) {
            return Math.sqrt(Math.pow(getR() - c.getR(), 2) +
                             Math.pow(getG() - c.getG(), 2) +
                             Math.pow(getB() - c.getB(), 2));
        }

        public String toString() {
            return (int)r + " " + (int)g + " " + (int)b;
        }

    }

    private int[] pixels;
    private final int k = 10; //numero de clusters
    private ArrayList<Color>[] clusters;
    private ArrayList<Color> clusterCenters;

    @SuppressWarnings("unchecked")
    public Main() {
        clusterCenters = new ArrayList<Color>();
        clusters = new ArrayList[k];
        for (int i = 0; i < k; i++) {
            clusters[i] = new ArrayList<Color>();
        }

        loadImage("./res/dress.png");
        classifyPixels();
    }

    public void loadImage(String path) {
        try {
            FileInputStream fs = new FileInputStream(new File(path));
            Image image = new Image(fs);
            int[] prePixels = new int[(int) image.getWidth() * (int) image.getHeight()];
            image.getPixelReader().getPixels(0, 0, (int) image.getWidth(), (int) image.getHeight(), WritablePixelFormat.getIntArgbInstance(), prePixels, 0, (int) image.getWidth());

            ArrayList<Integer> preBuffer = new ArrayList<Integer>();
            for (int i = 0; i < prePixels.length; i++) {
                if (getColorFromInt(prePixels[i]).euclidean(new Color(0xff, 0x00, 0xff)) == 0) {
                    continue;
                }

                preBuffer.add(prePixels[i]);
            }

            pixels = new int[preBuffer.size()];

            for (int i = 0; i < pixels.length; i++)  {
                pixels[i] = preBuffer.get(i);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Color getColorFromInt(int i) {
        int r = (int) ((i >> 16) & 0xff);
        int g = (int) ((i >> 8) & 0xff);
        int b = (int) ((i) & 0xff);

        return new Color(r, g, b);
    }

    public void randomizeClusters() {
        Random random = new Random();

        for (int i = 0; i < k; i++) {
            clusterCenters.add(getColorFromInt(pixels[random.nextInt(pixels.length)]));
        }
    }

    public Color calculateCenter(ArrayList<Color> colors) {
        double total = 0;
        int totalr = 0;
        int totalg = 0;
        int totalb = 0;

        for (Color c : colors) {
            total++;
            totalr += c.getR();
            totalg += c.getG();
            totalb += c.getB();
        }

        return new Color((totalr/total), (totalg/total), (totalb/total));
    }

    public int smallestDouble(double[] array) {
        double value = Double.MAX_VALUE;
        int index = 100;

        for (int i = 0; i < array.length; i++) {
            if (array[i] < value) {
                value = array[i];
                index = i;
            }
        }

        return index;
    }

    public void classifyPixels() {
        randomizeClusters();

        double tolerance = 0.001;
        double[] centerDistances = new double[k];
        boolean stop = false;

        while (!stop) {
            double[] pixelDistances = new double[k];

            for (Integer i : pixels) {
                Color pixelColor = getColorFromInt(i);

                for (int j = 0; j < k; j++) {
                    pixelDistances[j] = pixelColor.euclidean(clusterCenters.get(j));
                }

                int closest = smallestDouble(pixelDistances);

                clusters[closest].add(pixelColor);
            }

            ArrayList<Color> newCenters = new ArrayList<Color>();

            for (int i = 0; i < clusters.length; i++) {
                Color c = calculateCenter(clusters[i]);
                centerDistances[i] = c.euclidean(clusterCenters.get(i));
                newCenters.add(c);
            }

            clusterCenters = newCenters;

            stop = true;

            for (int i = 0; i < centerDistances.length; i++) {
                if (centerDistances[i] >= tolerance) {
                    stop = false;
                }
            }

            for (int i = 0; i < clusters.length; i++) {
                clusters[i].clear();
            }
        }

        for (int i = 0; i < clusterCenters.size(); i++) {
            System.out.println(clusterCenters.get(i));
        }
    }

    public static void main(String[] args) {
        new Main();
    }

}