import java.util.ArrayList;
import java.util.Scanner;

/**
 *
 */
public class Programa
{
    public static void main(String[] args)
    {
      /*  int x = 4;
        pakeistiSkaiciu(x);
        System.out.println(x);
        x = pakeistiSkaiciu2();
        System.out.println(x);*/

        //-------------------------------- KINTAMŲJŲ APRAŠYMAS --------------------------------------
        ArrayList<Double> ivestiUgiai = new ArrayList<>();
        ArrayList<Double> didesniUgiai = new ArrayList<>();             // ugiai, kurie yra didensi uz lyginamaji ugi
        double ugiuSuma;
        double ugiuVidurkis;
        int auksciausioIndeksas;
        int zemiausioIndeksas;

        double zemiausioUgis;
        double auksciausioUgis;

        double lyginamasUgis;

        int kiekAukstesniu;
        int kiekAukstesniuOverloadintoMetodo;

        int[] overloadintaSumosMasyvas = {3, 5, 7};
        int overloadintaSuma;


        //----------------------------------- ĮVEDIMO NUSKAITYMAS -------------------------------
        nuskaitymas(ivestiUgiai);
        System.out.println("Iveskite ugi, kuri tikrinsite su kitais ugiais (ar didesni, ar mazesni)");
        lyginamasUgis = nuskaitytiVienaDouble();
        System.out.println("lyginamas ugis: " + lyginamasUgis);


        //--------------------------------- REIKŠMIŲ PRISKYRIMAS ------------------------------
        ugiuSuma = arrayListSuma(ivestiUgiai);
        ugiuVidurkis = arrayListVidurkis(ivestiUgiai);
        auksciausioIndeksas = maxReiksmesIndeksas(ivestiUgiai);
        zemiausioIndeksas = minReiksmesIndeksas(ivestiUgiai);

        zemiausioUgis = ivestiUgiai.get(zemiausioIndeksas);
        auksciausioUgis = ivestiUgiai.get(auksciausioIndeksas);

        // Du kreipimaisi i overloadintus metodus
        kiekAukstesniu = kiekDidesniu(ivestiUgiai, lyginamasUgis, didesniUgiai);
        kiekAukstesniuOverloadintoMetodo = kiekDidesniu(ivestiUgiai, lyginamasUgis);

        // Overloadinta masyvo suma
        overloadintaSuma = arrayListSuma(overloadintaSumosMasyvas);


        //-------------------------------- REZULTATŲ IŠVEDIMAI---------------------------
        System.out.println(ivestiUgiai.toString());
        System.out.println("Visu ugiu suma: " + ugiuSuma);
        System.out.println("Ugiu vidurkis: " + ugiuVidurkis);

        System.out.println("Auksciausias zmogus buvo " + (auksciausioIndeksas + 1) + "-asis zmogus");
        System.out.println("Auksciausio zmogaus ugis: " + auksciausioUgis);

        System.out.println("Zemiausias zmogus buvo " + (zemiausioIndeksas + 1) + "-asis zmogus");
        System.out.println("Zemiausio zmogaus ugis: " + zemiausioUgis);

        System.out.println("Yra tiek aukštesnių ūgių už lyginamąjį: " + kiekAukstesniu);
        System.out.println("Šie ūgiai yra: " + didesniUgiai.toString());
        System.out.println("-----------------");
        System.out.println("O čia yra tiek aukštesnių iš overloadinto metodo: " + kiekAukstesniuOverloadintoMetodo);
        System.out.println("Čia būtų overladinta suma: " + overloadintaSuma);


    }

    // Pass by Reference
    public static void nuskaitymas(ArrayList<Double> ivestiUgiai)
    {
        Scanner skaitytuvas = new Scanner(System.in);

        String ivestasUgisStr;
        double ivestasUgis;

        ivestasUgisStr = skaitytuvas.next();
        while (!ivestasUgisStr.equals("q"))
        {
            ivestasUgis = Double.parseDouble(ivestasUgisStr);
            ivestiUgiai.add(ivestasUgis);
            ivestasUgisStr = skaitytuvas.next();
        }
    }


    public static double nuskaitytiVienaDouble()
    {
        Scanner skaitytuvas = new Scanner(System.in);

        double ugis;
        ugis = skaitytuvas.nextDouble();
        return ugis;
    }


    // Overloadinta masyvo suma - gauna double ARRAYLIST ir grazina double suma
    public static double arrayListSuma(ArrayList<Double> masyvoList)
    {
        double suma = 0;
        for (int i = 0; i < masyvoList.size(); i++)
        {
            suma += masyvoList.get(i);
            //suma = suma + masyvoList.get(i);
        }
        return suma;
    }


    // Neina overloadinti metodu jeigu juose yra tik tai ArrayList, kadangi nors ir tarp < > tagu paduodame skirtingą tipą,
    // Tačiau vis vien programa mato tik tiek, jog mes tiek viename, tiek kitame metode paduodame tik tai ArrayList tipo objektą
    public static int arrayListSumaInt(ArrayList<Integer> masyvoList)
    {
        int suma = 0;
        for (int i = 0; i < masyvoList.size(); i++)
        {
            suma += masyvoList.get(i);
            //suma = suma + masyvoList.get(i);
        }
        return suma;
    }


    // Overloadinta masyvo suma - gauna integer MASYVA ir grazina integer suma
    public static int arrayListSuma(int[] masyvoList)
    {
        int suma = 0;
        for (int i = 0; i < masyvoList.length; i++)
        {
            suma += masyvoList[i];
            //suma = suma + masyvoList.get(i);
        }
        return suma;
    }


    /**
     * Metodas apskaičiuoja gaunamo ArrayList elementų vidurkį.
     * @param masyvoList - gaunamas double ArrayList, kurio vidurkio ieškosime
     * @return grąžinamas vidurkis double formatu
     */
    public static double arrayListVidurkis(ArrayList<Double> masyvoList)
    {
        double masyvoSuma = arrayListSuma(masyvoList);
        int n = masyvoList.size();

        double vidurkis = masyvoSuma / n;
        return vidurkis;
    }


    public static int maxReiksmesIndeksas(ArrayList<Double> masyvoList)
    {
        int maxIndeksas = 0;
        for (int i = 1; i < masyvoList.size(); i++)
        {
            if (masyvoList.get(i) > masyvoList.get(maxIndeksas))
            {
                maxIndeksas = i;
            }
        }
        return maxIndeksas;
    }


    public static int minReiksmesIndeksas(ArrayList<Double> masyvoList)
    {
        int minIndeksas = 0;
        for (int i = 1; i < masyvoList.size(); i++)
        {
            if (masyvoList.get(i) < masyvoList.get(minIndeksas))
            {
                minIndeksas = i;
            }
        }
        return minIndeksas;
    }

    /**
     * Overloadintas metodas, kuris grąžina kiek ir kokie yra didesni elementai už lyginamą elementą
     * @param masyvoList - gaunamas double ArrayList, kurio elementus lyginsime
     * @param lyginamasSk - reikšmė, su kuria lyginsime masyvo skaičius
     * @param didesniElementai - gaunamas double ArrayList į kurį pridėtume tuos elementus, kurie yra didesni už lyginamą reikšmę
     * @return - grąžina int reikšmę, kiek yra didesnių elementų už lyginamą
     */
    // Overlaodintas metodas - taip pat gauna dar ir papildoma arraylist, jame saugo didesnius elementus
    public static int kiekDidesniu(ArrayList<Double> masyvoList, double lyginamasSk, ArrayList<Double> didesniElementai)
    {
        int kiekDaugiau = 0;
        for (int i = 0; i < masyvoList.size(); i++)
        {
            if (masyvoList.get(i) > lyginamasSk)
            {
                kiekDaugiau++;
                //kiekDaugiau = kiekDaugiau + 1;

                didesniElementai.add(masyvoList.get(i));
            }
        }
        return kiekDaugiau;
    }


    // Overloadintas metodas - jis tik tai grazina kiek didesniu, bet nesaugo arraylist
    public static int kiekDidesniu(ArrayList<Double> masyvoList, double lyginamasSk)
    {
        int kiekDaugiau = 0;
        for (int i = 0; i < masyvoList.size(); i++)
        {
            if (masyvoList.get(i) > lyginamasSk)
            {
                kiekDaugiau++;
                //kiekDaugiau = kiekDaugiau + 1;
            }
        }
        return kiekDaugiau;
    }





















    // Pass by Value
    public static void pakeistiSkaiciu(int x)
    {
        x = 25;
        System.out.println("Viduje metodo: " + x);
    }

    // Norint pakeisti skaiciu
    public static int pakeistiSkaiciu2()
    {
        return 25;
    }
}