package pigment;

import java.lang.Math.*;
import java.util.ArrayList;
import Jama.*;

class Counting
{
   Counting(){}                     //pusty konstruktor klasy

   static void sort(String[] a, double[]...arg) //metoda sortowania bąbelkowego o zmien-
   {            //nej liczbie argumentów. Metoda sortuje
        double[] temp=new double[arg.length+1]; //malejąco element tablicy, która jest dru-
        String temp1;                //gim argumentem wywołania, w pozostałych
                         //Zmienia pozycje elementów względem posor-
        int change = 1;              //towanej tablicy*/

        while(change>0)
        {
            change=0;
            for(int j=0; j<a.length-1; j++)
            {
                if(arg[0][j]<arg[0][j+1])
                {
                    temp1=a[j+1];
                    a[j+1]=a[j];
                    a[j] = temp1;

                    for(int k=0; k<arg.length; k++)
                    {
                        temp[k]=arg[k][j+1];
                        arg[k][j+1]=arg[k][j];
                        arg[k][j] = temp[k];
                    }
                    change++;
                }
            }
        }
   }

     static ArrayList<String> check_similarity(String path, String back, ArrayList<Item> list_of_pigments)
    {      /*metoda wyznaczająca podobieństwo między widmami
            metoda zwraca obiekt typu ArrayList, który zawiera nazwę ba-
           danej próbki oraz wykaz pigmentów bazowych z wyliczonymi współczynnikami podobieństwa*/
        ArrayList<String> result=new ArrayList<>();
        String[] base_name=new String[list_of_pigments.size()];
                                                                                                         //tablica przechowująca nazwy pigmentów referen-
        Item unknown=new Item(path, back);                        //cyjnych
        unknown.set_everything();                                           //dokonanie reprezentacji widma badanego w postaci
                                                                                                        //obiektu Item
        double[] wavesx=unknown.get_waves();                //tablice charaktersytyk widma badanego
        double[] reflectancesx=unknown.get_reflectance();
        double[] errorsx=unknown.get_error();
        int unknown_size=unknown.get_size();
        String unknown_name=unknown.get_name();
        //tablica przechowująca wartości współczynników podobieństwa oraz ich niepewność
        double[][] array_of_similarity=new double [2][list_of_pigments.size()];

        double[] mintab1=list_of_pigments.get(0).get_waves();
        double min=mintab1[0];
        double max=mintab1[mintab1.length-1];

         for(int x=0; x<list_of_pigments.size(); x++)
         {
             double[] mintab=list_of_pigments.get(x).get_waves();  //sprawdzenie, które z widm ma najwęższe
                                                                                            //spektrum odbiciowe
             if(mintab[0]>min)
             {
                 min=mintab[0];
             }
             else if(mintab[mintab.length-1]<max)
             {
                 max=mintab[mintab.length-1];
             }
         }

        for (int i=0; i<list_of_pigments.size(); i++) //pętla po wszystkich elementach
        {                                                                                //biblioteki
            double similarity=0.0;
            double uncertain_of_similarity;
            double sum_of_errorsx=0.0;     //zmienne pomocnicze w wyznaczaniu niepewności
            double sum_of_errorsb=0.0;
            double size=0.0;

            double[] wavesb=list_of_pigments.get(i).get_waves();     //tablice charakterystyk
            double[] reflectancesb= list_of_pigments.get(i).get_reflectance(); //widma
            double[] errorsb= list_of_pigments.get(i).get_error();  //referencyjnego
            int base_size=list_of_pigments.get(i).get_size();

            base_name[i]=list_of_pigments.get(i).get_name();    //zapamiętanie nazwy pi-
                                    //gmentu bazowego
            for(int j=0; j<unknown_size; j++)   //pętla przechodząca po wszyst-kich pun-
            {           //ktach widma badanego porównania dokonuje się w zakresie fal
                for(int k=0; k<base_size; k++)                                                    //widma badanego
                {
                    if(wavesx[j]>=min&&wavesx[j]<=max)
                    {
                        if(wavesx[j]==wavesb[k])                            //wartości odbić można porównać wówczas,gdy
                        {                                                                           //przypisane są tej samej długości fali
                           similarity=similarity+Math.pow(reflectancesx[j]-reflectancesb[k], 2.0);
                           size=size+1.0;         //zgodnie z 3.4.1 wyznacza się kwadrat różnicy reflektancji
                                                                 //obliczenia niepewności wg 3.4.2
                            sum_of_errorsx=sum_of_errorsx+Math.pow(errorsx[j]*(reflectancesb[k]-reflectancesx[j]), 2.0);

                            sum_of_errorsb=sum_of_errorsb+Math.pow(errorsb[k]*(reflectancesb[k]-reflectancesx[j]), 2.0);
                        }

                        if(k!=base_size-1)
                        {
                            if(wavesx[j]>wavesb[k] && wavesx[j]<wavesb[k+1])
                            {                                                                // jeżeli wartość odbicia widma bazowego nie przypada
                                double x1=wavesb[k];                   //na tą samą długość fali, co wi-
                                double y1=reflectancesb[k];        //dma badanego, wówczas war-tość ref-
                                double x2=wavesb[k+1];              //lektancji szacuje się wyznaczając
                                double y2=reflectancesb[k+1];    //prostą łączącą dwa punkty, których
                                double z=wavesx[j];              //odcięte ograniczają badaną długość
                                                                                            //fali
                                double ref=y1+((z-x1)*((y2-y1)/(x2-x1)));

                                similarity=similarity+Math.pow(reflectancesx[j]-ref, 2.0);
                                 size=size+1.0;
                                //z prawa przenoszenia niepewności wyznacza się niepewność otrzymanej wartości odbicia
                                double error_of_ref=Math.sqrt(Math.pow((1+((z+x1)/(x2-x1)))*errorsb[k],2.0)+Math.pow(((z-x1)/(x2-x1))*errorsb[k+1],2.0));

                                sum_of_errorsx=sum_of_errorsx+Math.pow(errorsx[j]*(ref-reflectancesx[j]), 2.0);
                                sum_of_errorsb=sum_of_errorsb+Math.pow(error_of_ref*(ref-reflectancesx[j]), 2.0);
                            }
                        }
                    }
                }
            }

            similarity=similarity/size; //S i u(S) według 3.4.1 i 3.4.2
            uncertain_of_similarity=(Math.sqrt( sum_of_errorsx+sum_of_errorsb))/size;

            array_of_similarity[0][i]=Math.exp(-similarity)*100.0;
            array_of_similarity[1][i]=Math.exp(-similarity)*100.0*uncertain_of_similarity;
        }

        double[] array1=new double[list_of_pigments.size()];      //tablice pomocnicze,
        double[] array2=new double[list_of_pigments.size()];      //dzięki którym możliwe
                                                               //jest posortowanie otrzymanej tablicy podobieństw
        for(int z=0; z<list_of_pigments.size(); z++)
        {
            array1[z]=array_of_similarity[0][z];
            array2[z]=array_of_similarity[1][z];
        }

        sort(base_name, array1, array2);    //sortowanie tablicy podobieństw, niepewności
                //oraz nazwy pigmentów zmieniają tak swoje poło-
        result.add(unknown_name);   //żenie w tablicy, aby odpowiadały wartościom S
        result.add("\n");

        for(int z=0; z<list_of_pigments.size(); z++)
        {
            result.add("Pigment  \t"+base_name[z]+"  \tS: \t"+Double.toString(array1[z])+"\t  u(S): \t "+Double.toString(array2[z]));
                          //wypełnienie listy otrzymanymi wartościami
        }
        result.add("\n");

        return result;
}

    static ArrayList<String> count_SAM(String path, String back, ArrayList<Item> list_of_pigments)
    { //metoda wyliczająca współczynnik SAM podobieństw widm. Stworzona analogicznie do
        ArrayList<String> result=new ArrayList<>();     /*metody check_similarity(), różni się je-
                                                                            dynie wzorem na współczyn-nik i jego niepewność*/

        String[] base_name=new String[list_of_pigments.size()];

        Item unknown=new Item(path, back);
        unknown.set_everything();

        double[] wavesx=unknown.get_waves();
        double[] reflectancesx=unknown.get_reflectance();
        double[] errorsx=unknown.get_error();
        int unknown_size = unknown.get_size();
        String unknown_name=unknown.get_name();

        double [][] array_of_sam = new double [2][list_of_pigments.size()];

         double[] mintab1=list_of_pigments.get(0).get_waves();
         double min=mintab1[0];
         double max=mintab1[mintab1.length-1];

          for(int x=0; x<list_of_pigments.size(); x++)
          {
             double[] mintab=list_of_pigments.get(x).get_waves(); //sprawdzenie, które z widm ma najwęższe
                                                                                            //spektrum odbiciowe
             if(mintab[0]>min)
             {
                 min=mintab[0];
             }
             else if(mintab[mintab.length-1]<max)
             {
                 max=mintab[mintab.length-1];
             }
          }

        for (int i=0; i<list_of_pigments.size(); i++)
        {
            double sam;
            double sum1 = 0.0;      //zmienne pomocnicze do wyznaczenia SAM
            double sum2 = 0.0;
            double sum3 = 0.0;
            double uncertain_of_sam;

            double[]wavesb=list_of_pigments.get(i).get_waves();
            double[]reflectancesb=list_of_pigments.get(i).get_reflectance();
            double[]errorsb=list_of_pigments.get(i).get_error();
            int base_size=list_of_pigments.get(i).get_size();

            base_name[i]=list_of_pigments.get(i).get_name();

            for(int j=0; j<unknown_size; j++)
            {
                if(wavesx[j]>=min&&wavesx[j]<=max)
                {
                    for(int k=0; k<base_size; k++)
                    {
                        if(wavesx[j]==wavesb[k])
                        {
                           sum1=sum1+(reflectancesx[j]*reflectancesb[k]);   //licznik SAM oraz
                           sum2=sum2+(Math.pow(reflectancesx[j], 2.0));     //czynniki mianownika
                           sum3=sum3+(Math.pow(reflectancesb[k], 2.0));     //wg 1.3.4 oraz 3.4.3
                        }

                        if(k!=base_size-1)
                        {
                            if(wavesx[j]>wavesb[k]&& wavesx[j]<wavesb[k+1])
                            {
                                double x1=wavesb[k];
                                double y1=reflectancesb[k];
                                double x2=wavesb[k+1];
                                double y2=reflectancesb[k+1];
                                double z=wavesx[j];

                                double ref= y1+((z-x1)*((y2-y1)/(x2-x1)));

                                sum1=sum1+(reflectancesx[j]*ref);
                                sum2=sum2+(Math.pow(reflectancesx[j], 2.0));
                                sum3=sum3+(Math.pow(ref, 2.0));
                            }
                        }
                    }
                }
            }

            sam = Math.acos((sum1)/((Math.sqrt(sum2))*(Math.sqrt(sum3))));

            double xb=sum1;    //zmienne pomocnicze do wyznaczenia niepewności SAM
            double xx=sum2;
            double bb=sum3;
            double a;
            double b;
            double suma=0.0;
            double sumb=0.0;

             for(int m=0; m<unknown_size; m++)   //w celu wyznaczenia u(SAM) konieczne
            {                    //jest ponowne przejscie po wszystkich elementach widma badanego
                 if(wavesx[m]>=min&&wavesx[m]<=max)
                 {
                    for(int n=0; n<base_size; n++)
                    {
                        if(wavesx[m]==wavesb[n])
                        {
                           a=((reflectancesb[n]*xb*Math.sqrt(xx))-(reflectancesx[m]*bb*Math.sqrt(xx)))/(xx*Math.pow(bb, 1.5)*(Math.sqrt(1-((xb)/(Math.sqrt(xx)*Math.sqrt(bb))))))*errorsb[n];
                           b=((reflectancesx[m]*xb*Math.sqrt(bb))-(reflectancesb[n]*xx*Math.sqrt(bb)))/(bb*Math.pow(xx, 1.5)*(Math.sqrt(1-((xb)/(Math.sqrt(xx)*Math.sqrt(bb))))))*errorsx[m];

                           suma=suma+Math.pow(a, 2.0);
                           sumb=sumb+Math.pow(b, 2.0);
                        }

                        if(n!=base_size-1)
                        {
                            if(wavesx[m]>wavesb[n]&& wavesx[m]<wavesb[n+1])
                            {
                                double x1=wavesb[n];
                                double y1=reflectancesb[n];
                                double x2=wavesb[n+1];
                                double y2=reflectancesb[n+1];
                                double z=wavesx[m];

                                double ref= y1+((z-x1)*((y2-y1)/(x2-x1)));

                                double error_of_ref=Math.sqrt(Math.pow((1+((z+x1)/(x2-x1)))*errorsb[n],2.0)+Math.pow(((z-x1)/(x2-x1))*errorsb[n+1],2.0));

                                a=((reflectancesb[n]*xb*Math.sqrt(xx))-(reflectancesx[m]*bb*Math.sqrt(xx)))/(xx*Math.pow(bb, 1.5)*(Math.sqrt(1-((xb)/(Math.sqrt(xx)*Math.sqrt(bb))))))*errorsb[n];
                                b=((reflectancesx[m]*xb*Math.sqrt(bb))-(ref*xx*Math.sqrt(bb)))/(bb*Math.pow(xx, 1.5)*(Math.sqrt(1-((xb)/(Math.sqrt(xx)*Math.sqrt(bb))))))*error_of_ref;

                                suma=suma+Math.pow(a, 2.0);
                                sumb=sumb+Math.pow(b, 2.0);
                            }
                        }
                     }
                 }
              }

            uncertain_of_sam=Math.sqrt(suma+sumb);

            array_of_sam [0][i]=Math.exp(-sam)*100.0;
            array_of_sam[1][i]=Math.exp(-sam)*100.0*uncertain_of_sam;
        }

         double[] array1=new double[list_of_pigments.size()];
         double[] array2=new double[list_of_pigments.size()];

         for(int z=0; z<list_of_pigments.size(); z++)
         {
            array1[z]=array_of_sam[0][z];
            array2[z]=array_of_sam[1][z];
         }

         sort(base_name, array1, array2);    //sortowanie

         result.add(unknown_name);
         result.add("\n");

         for(int z=0; z<list_of_pigments.size(); z++)
         {
            result.add("Pigment\t  "+base_name[z]+"  \tSAM:\t  "+Double.toString(array1[z])+"  \tu(SAM):\t  "+Double.toString(array2[z]));
         }
         result.add("\n");

        return result;
    }

    static ArrayList<String> check_containing(String path, String back, ArrayList<Item> list, String option)
    {   //metoda wyznaczająca składowe widm mieszanych, jej konstukcja
        ArrayList<String> result=new ArrayList<>();   /*również jest podobna do budowy
                                                                                                    dwóch poprzednich metod*/
         String[] base_name=new String[list.size()];

        Item unknown=new Item(path, back);
        unknown.set_everything();

        double[] unknown_wave=unknown.get_waves();         //widmo badane
        double[] unknown_ref=unknown.get_reflectance();
        int unknown_size=unknown.get_size();
        String unknown_name=unknown.get_name();

        double[] temporary_ref ;
        double[] temporary_wave;

        double min=unknown_wave[0];
        double max=unknown_wave[unknown_wave.length-1];

        for(int x=0; x<list.size(); x++)
        {
            double[] mintab=list.get(x).get_waves();    //sprawdzenie, które z widm ma najwęższe
                                                                                            //spektrum odbiciowe
            if(mintab[0]>min)
            {
                min=mintab[0];
            }
            else if(mintab[mintab.length-1]<max)
            {
                max=mintab[mintab.length-1];
            }
        }

        ArrayList<Double>  matrixA=new ArrayList<>();
        ArrayList<Double> matrixB=new ArrayList<>();
       //lista matrixA przechowuje punkty widm bazowych, matrixB punkty widma badanego wg wzoru 3.4.7
        Matrix a;
        Matrix b;
        Matrix x;

        for(int i=0; i<list.size(); i++) //pętla przechodząca po elementach bazy
        {
            temporary_wave = list.get(i).get_waves();   //długość fali i odbicie widma
            temporary_ref = list.get(i).get_reflectance();  //bazowego

            base_name[i]=list.get(i).get_name();    //tablica przechowująca nazwę widma bazy

            for(int j=0; j<unknown_size; j++)   //pętla przechodząca po wszytskich pun-
            {           //ktach widma badanego
                if((unknown_wave[j]>=min)&&(unknown_wave[j]<=max)) //widmo jest analizowane tylko
                {                                                               //w najwęższym możliwym zakresie długości fal
                    for(int k=0; k<list.get(i).get_size(); k++)  //pętla przechodząca po wszystkich punktach wi-
                    {                                                               //dma odniesienia
                        if (unknown_wave[j]==temporary_wave[k])
                        {
                             matrixA.add(temporary_ref[k]);   //wypełnianie matrixA wartościa-
                        }               //mi odbić widm bazowych

                        else if (unknown_wave[j]>temporary_wave[k]&&unknown_wave[j]<temporary_wave[k+1])
                        {
                            double x1=temporary_wave[k];
                            double y1=temporary_ref[k];
                            double x2=temporary_wave[k+1];
                            double y2=temporary_ref[k+1];
                            double z=unknown_wave[j];

                            matrixA.add(y1+((z-x1)*((y2-y1)/(x2-x1))));
                        }
                    }
                }
            }
        }

        for(int m=0; m<unknown_size; m++)   //wypełnianie matrixB wartościami odbić widma
        {           //analizowanego
            if((unknown_wave[m]>=min)&&(unknown_wave[m]<=max))
            {
                matrixB.add(unknown_ref[m]);
            }
        }

        double[][] mb=new double[matrixB.size()][1];    //tablice pomocnicze w stworzeniu macierzy a i b
        double[][] ma=new double[matrixA.size()/list.size()][list.size()];

        for(int t=0; t<matrixB.size(); t++)
        {
            mb[t][0]=matrixB.get(t);
        }
        int counter1=0;
        int counter2=0;

        for(int t=0; t<matrixA.size(); t++)
        {
            if(counter1==(matrixA.size()/list.size()))
            {
                counter1=0;
                counter2++;
                ma[t-((matrixA.size()/list.size())*counter2)][counter2]=matrixA.get(t);
                counter1++;
            }
            else
            {
                ma[t-((matrixA.size()/list.size())*counter2)][counter2]=matrixA.get(t);
                counter1++;
            }
        }

        a=new Matrix(ma);      //utworzenie obiektów macierzowych z wyznaczonych
        b=new Matrix(mb);      //list matrixA i matrixB

        x = Matrixes.find_overdetermined(a, b); /*rozwiązanie problemu najmniejszych kwadra-
         tów dla macierzy a i b; metoda nazywa się find_overdetermined(), gdyż rozważany układ*/
        int number_of_minus_item=0;             //ma więcej równań niż niewiadomych, jest nad-
        ArrayList<Integer> counters=new ArrayList<>();  //określony

         for(int g=0; g<x.getRowDimension(); g++)   //wyznaczenie ilości ujemnych współczyn-
        {                                                                                   //ników w otrzymanym rozwiązaniu oraz ich
           if(x.get(g, 0)<0)                                                    //sumy
           {
                number_of_minus_item++;
                counters.add(g);
           }
        }

        while(number_of_minus_item>0) //dopóki liczba ujemnych współczynnikow nie ró-
        {                                                                //wna się zeru, należy wykonać poniższe operacje
            double sum_of_coefficient=0.0;
            ArrayList<String> similarity=new ArrayList<>();
            double[] s=new double[list.size()];
            int counter=0;

            if(option.equals("S"))              //dobór algorytmu, wg którego ma się odbyć poró-
            {                                                   //wnywanie widm
                similarity=Counting.check_similarity(path, back, list);
            }
            else if(option.equals("SAM"))
            {
                similarity=Counting.count_SAM(path, back, list);
            }

            for(int i=0; i<s.length; i++)
            {
                s[i]=Double.parseDouble(similarity.get(5+i*6));
            }

            for(int g=0; g<x.getRowDimension(); g++)
            {
                if(x.get(g, 0)<0)                                        //suma ujemnych współczynników
                {
                    sum_of_coefficient=sum_of_coefficient+s[g];
                    counter++;
                }
            }

            for(int g=0; g<x.getRowDimension(); g++)
            {
                if(x.get(g, 0)<0)
                {
                    if(g==counters.get(0))
                    {
                        x.set(g, 0, 0.0);
                    }
                    sum_of_coefficient=sum_of_coefficient+(1/s[g]);
                }
            }

            for(int g=0; g<x.getRowDimension(); g++)
            {
                if(x.get(g, 0)<0)     //przydzielenie wag ujemnych współczynników dodatnim
                {
                    x.set(g, 0, x.get(g,0)-(x.get(counters.get(0), 0)*(1/s[g])/sum_of_coefficient));
                }
            }

            number_of_minus_item=0;
            counters.removeAll(counters);

            for(int g=0; g<x.getRowDimension(); g++)
            {
                if(x.get(g, 0)<0)
                {
                    number_of_minus_item++;
                    counters.add(g);
                }
            }
        }

        double sum=0.0;

        for(int g=0; g<x.getRowDimension(); g++)
        {
            sum=sum+x.get(g, 0);
        }

        for(int g=0; g<x.getRowDimension(); g++)
        {
            x.set(g, 0, (x.get(g, 0))/sum);         //normalizacja otrzymanych wag
        }

        double[] array1=new double[list.size()];

         for(int z=0; z<list.size(); z++)
         {
            array1[z]=x.get(z, 0);
         }

         sort(base_name, array1);   //sortowanie otrzymanych wyników

         result.add(unknown_name+"\n");

         for(int z=0; z<list.size(); z++)
         {
            result.add("Pigment \t "+base_name[z]+"\t  containing:  \t"+Double.toString(array1[z]));
         }
         result.add("\n");

        return result;
    }
}