package ipalp_cv07;

import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Locale;
import java.util.Scanner;

/**
 * Zadání:
 * <p>
 * Cílem je naprogramovat jednoduché operace s dvojrozměrným polem. Těmi
 * operacemi bude například sčítání a odečítání dvou dvojrozměrných matic čísel
 * nebo operace matice (2d pole) a 1d pole nebo matice a cislo. Proto, aby se
 * mohly tyto operace uskutečnit je zapotřebí získat rozměry matic a naplnit je
 * hodnotami, takže budou zapotřebí dvě metody, které bezpečně převezmou číselné
 * hodnoty z klávesnice. Dále nezbytnou metodou bude sestavení výstupního textu
 * s obsahem matic.
 * <p>
 *
 * S čím se seznámíte a co bude procvičeno:
 * <ol>
 * <li> Z důvodu postupného seznamování s programováním v Java, bude toto
 * cvičení využívat pouze statické členy třídy. Zřizování instancí a tedy tvorbu
 * instančních metod bude předmětem následujícího cvičení.</li>
 *
 * <li> Rozdělení celkové funkce do metod, kdy každá metoda bude provádět pouze
 * jeden úkol. </li>
 *
 * <li> Metody budou opatřeny modifikátorem <code>static</code>. Bude se tedy
 * jednat o metody třídy. </li>
 *
 * <li>
 * Ověření některých metod bude přloženým JUnit testem v Test Packages. Budou se
 * testovat pouze metody, které nejsou součástí uživatelského rozhraní.
 *
 * <li> Ostatní metody, to jsou ty co komunikují s uživatelem, se ověří v hlavní
 * metodě main.</li>
 *
 * </ol>
 *
 * @author karel@simerda.cz
 */
public class IpalpCv07 {

    private static final Scanner input = new Scanner(System.in);

    public static void main(String[] args) {
        input.useLocale(Locale.ENGLISH);
        System.out.println("Zadejte počet řádků a počet sloupců matice");
        int pocetRadku = nactiCeleKladneCislo("Zadej počet řádků:");
        int pocetSloupcu = nactiCeleKladneCislo("Zadej počet sloupců:");

        double pocetRadkuRealneCislo = nactiRealneCislo("Zadej počet řádků reálná čísla:");
        double pocetSloupcuRealneCislo = nactiRealneCislo("Zadej počet sloupců reálná čísla:");

        double[][] m1 = nactiMatici("Zadej prvky matice M1\n", pocetRadkuRealneCislo, pocetSloupcuRealneCislo);

        double[][] m2 = nactiMatici("Zadej prvky matice M2\n", pocetRadku, pocetSloupcu);

        double[][] m3 = secti(m1, m2);

        System.out.println("Matice M1\n" + matice2string(m1, "%4.1f "));
        System.out.println("Matice M2\n" + matice2string(m2, "%4.1f "));
        System.out.println("Matice M1+M2\n" + matice2string(m3, "%4.1f "));

        // TODO Doplňte použití ostatních metod s operacemi
    }

    /**
     * Metoda načte celé kladné číslo z klávesnice.
     * <p>
     * Popis činnosti metody:
     * <ol>
     * <li> Nejdřive metoda text z parametru echo.
     *
     * <li> Metoda zavolá metodu nextInt v objektu typu Scanner.
     *
     * <li> Jestliže však bylo na klávesnici zadáno záporné číslo, nula nebo byl
     * porušen formát čísla, tak se před echo předřadí text "Zadej znovu. ",
     * který se vypíše jako nová výzva a čtení čísla se zopakuje.
     *
     * <li>Když je vše v pořádku je metoda ukončena s číselnou hodnotu.
     * </ol>
     *
     * @param echo Textový řetězec s výzvou.
     *
     * @return Vrací celé kladné číslo.
     */
    public static int nactiCeleKladneCislo(String echo) {
        System.out.print(echo);
        while (true) {
            try {
                int cislo = input.nextInt();
                if (cislo > 0) {
                    return cislo;
                }
            } catch (InputMismatchException ex) {
                System.out.println("Chybný formát čísla.");
                input.nextLine();
            }
            System.out.print("Zadej znovu. " + echo);
        }
    }

    /**
     * Metoda načte reálné číslo z klávesnice.
     *
     * Popis tvorby této metody je shodný s popisem metody
     * <code>nactiCeleKladneCislo</code>
     *
     * @param echo Textový řetězec s výzvou.
     *
     * @return Vrací reálné číslo typu double.
     */
    public static double nactiRealneCislo(String echo) {
        System.out.print(echo);
        while (true) {
            try {
                double realneCislo = input.nextDouble();
                if (realneCislo > 0) {
                    return realneCislo;
                }
            } catch (InputMismatchException ex) {
                System.out.println("Chybný formát čísla.");
                input.nextLine();
            }
            System.out.print("Zadej znovu. " + echo);
        }

    }

    /**
     * Metoda načte z klávesnice hodnoty dvojrozměrného pole reálných čísel.
     * <p>
     * Popis činnosti metody:
     * <ol>
     * <li> Nejprve metoda zkontroluje hodnoty parametrů s počtem řádků a
     * sloupců, zda jsou větší jak nula. </li>
     *
     * <li>Když bude mít alespoň jeden parametr hodnotu nula nebo zápornou,
     * metoda se ukončí návratem s referencí na dvojrozměrné pole o nulových
     * rozměrech. </li>
     *
     * <li>Když je vše v pořádku, vypíše metoda textový řetězec v parametru
     * <code>vyzva</code>. Výzva může být prázdná nebo žádná tj.
     * <code>null</code> ale potom se nic nevypíše.</li>
     *
     * <li>Dále je zapotřebí vytvořit nové dvojrozměrné pole o rozměrech dané
     * parametry metody. Referenci na toto pole si metda uloží do lokální
     * proměnné</li>
     *
     * <li> Jádrem metody budou dva do sebe vnořené cykly <code>for</code>.
     * Druhý cyklus bude vnořen do prvního. Tyto dva cykly budou sloužit k
     * postupnému načtení dvojrozměrného pole hodnotami zadávané z klávesnice.
     * </li>
     *
     * <li>Na převzetí čísla z klávesnice metoda použije metodu
     * <code>nactiRealneCislo</code>. </li>
     *
     * <li>Volání metody <code>nactiRealneCislo</code> bude mít tento argument
     * <code>String.format("Zadej prvek matice [%02d][%02d]:", i, j)</code>
     * </li>
     *
     * <li> Po ukončení cyklu se metoda ukončí návratem s referencí na lokální
     * proměnnou s naplněným dvojrozměrným polem reálných čísel.</li>
     * </ol>
     *
     * @param vyzva Textový řetězec, který se vypíše před načítáním jednotlivých
     * prvků pole.
     * @param pocetRadku Počet řádků dvojrozměrného pole.
     * @param pocetSloupcu Počet sloupců dvojrozměrného pole.
     *
     * @return Vrací referenci na dvojrozměrné pole reálných čísel podle toho,
     * jak se dopadla kontrola vstupních parametrů.
     */
    public static double[][] nactiMatici(String vyzva, double pocetRadkuRealneCislo, double pocetSloupcuRealneCislo) {

        if (pocetSloupcuRealneCislo <= 0 && pocetRadkuRealneCislo <= 0) {
            return new double[0][0];
        }

        System.out.println(vyzva);
        double[][] matice = new double[pocetRadkuRealneCislo][pocetSloupcuRealneCislo];

        double temp;

        for (int i = 0; i < pocetRadkuRealneCislo; i++) {
            for (int j = 0; j < pocetSloupcuRealneCislo; j++) {
                temp = nactiRealneCislo(String.format("Zadej prvek matice [%02d][%02d]:", i, j));
                matice[i][j] = temp;

            }
        }
        return matice;
    }

    /**
     * Metoda sestaví textový řetězec z obsahu matice reálných čísel po řádcích
     * a každou hodnotu prvku matice zformátuje podle parametru s formátem.
     * <p>
     * Popis činnosti metody:
     * <ol>
     * <li>Nejprve metoda překontroluje, zda parametry neobsahují
     * <code>null</code>.
     * </li>
     *
     * <li>Když ano, metoda se ukončí s návratem tohoto hlášení:
     * <p>
     * "Chybí reference na matici nebo na formát."
     * </li>
     *
     * <li>Když bude vše v pořádku, tak metoda vytvoří instance
     * <code>StringBuilder</code> pro uchování dílčích textů s hodnotami prvků
     * matice.</li>
     *
     * <li>Potom metdase dvojitým cyklem <code>for</code> postupně převedou
     * číselné hodnoty prvků matice na text tímto:
     * <p>
     * <code>String.format(Locale.ENGLISH, format, matice[i][j])</code> a dílčí
     * řetězce se přidají do instance třídy  <code>StringBuilder</code>.
     * </li>
     *
     * <li>Při přechodu z jednoho řádku matice na druhý se provede přidání do
     * instance třídy  <code>StringBuilder</code> přechod na nový řádek. </li>
     *
     * <li>Po ukončení cyklů metoda převede obsah instance
     * <code>StringBuilder</code> na jeden textový řetězec a reference na tento
     * řetězec metoda použije při návratu.</li>
     * </ol>
     *
     *
     * @param matice Reference na dvojrozměrné pole reálných čísel.
     * @param format Řetězec s formátem převodu jednoho reálného čísla z prvků
     * matice.
     *
     * @return Vrací textový řetězec s převedeným obsahem matice raálných čísel.
     */
    public static String matice2string(double[][] matice, String format) {
        if (matice == null || format == null) {
            return ("Chybí reference na matici nebo na formát.");
        } else {
            StringBuilder strBuilder = new StringBuilder();

            for (int i = 0; i < matice.length; i++) {
                for (int j = 0; j < matice[i].length; j++) {
                    strBuilder.append(String.format(Locale.ENGLISH, format, matice[i][j]));
                }
                strBuilder.append("\n");
            }
            String vysledek = new String(strBuilder);
            return vysledek;
        }

    }

    /**
     * Metoda sečte dvě 2d pole (matice) stejného rozměru.
     * <p>
     * Sčítanec + sčítanec = součet
     **<p>
     * Popis činnosti metody:
     * <ol>
     * <li>Metoda nejdříve provede kontrolu, zda obě vstupní 2d pole mají stejné
     * rozměry.</li>
     *
     * <li>Když se rozměr nebude shodovat, tak se metoda ukončí s referencí na
     * 2d pole s nulovou velikostí v každém rozměru. </li>
     *
     * <li>Pokud se rozměry shodují, vytvoří metoda nové dvojrozměrné pole,
     * stejného typu jako jsou vstupní pole.</li>
     *
     * <li> Metoda uloží referenci na nově 2d pole do lokální proměnné
     * <code>soucet</code>.</li>
     *
     * <li>Potom pomocí dvou vnořených cyklů <code>for</code> metoda do nového
     * 2d pole provede výpočet součtu stejnolehlých prvků vstupních 2d polí.
     * </li>
     *
     * <li>Po ukončení cyklů se metoda ukončí návratem s referencí na 2d pole
     * <code>soucet</code>.</li>
     * </ol>
     *
     * @param m1 2d pole (matice) jako levý operand (sčítanec) součtu.
     * @param m2 2d pole (matice) jako pravý operand (sčítanec) součtu.
     *
     * @return Vrací součet dvou 2d polí (matic). Pokud nejsou operandy stejného
     * rozměru, vrací se 2d pole o rozměru double [0][0].
     */
    public static double[][] secti(double[][] m1, double[][] m2) {

//        int pocetRadku = m1.length;
//        int pocetSloupcu = m1[0].length;
        if (m1.length != m2.length || m1[0].length != m2[0].length) {
            return new double[0][0];
        } else {
            double soucet[][] = new double[m1.length][m1[0].length];

            for (int i = 0; i < m1.length; i++) {
                for (int j = 0; j < m1[i].length; j++) {
                    soucet[i][j] = m1[i][j] + m2[i][j];
                }
            }

            return soucet;
        }

    }

    /**
     * Metoda odečte 2d pole (matici od matice) stejného rozměru.
     * <p>
     * Menšenec - menšitel = rozdíl
     * <p>
     * <ol>
     * <li>Metoda nejdříve provede kontrolu, zda obě vstupní 2d pole mají stejný
     * rozměr.</li>
     *
     * <li>Když se rozměry nebudou shodovat, tak se metoda ukončí referencí na
     * 2d pole (matici) s nulovou velikostí v každém rozměru. </li>
     *
     * <li>Pokud se rozměry shodují, vytvoří metoda nové dvojrozměrné pole,
     * stejného typu jako jsou vstupní 2d pole.
     *
     * <li> Metoda referenci na nové 2d pole uloží do lokální proměnné
     * <code>rozdil</code>. </li>
     *
     * <li>Potom metoda pomocí dvou vnořených cyklů <code>for</code> do nového
     * 2d pole provede výpočet rozdílu stejnolehlých prvků vstupních matic.</li>
     *
     * <li>Po ukončení cyklů se metoda ukončí návratem s referencí na nové 2d
     * pole <code>rozdíl</code>.</li>
     *
     * @param m1 2d pole (matice) jako levý operadd (menšenec) rozdílu.
     * @param m2 2d pole (matice) jako pravý operand (menšitel) rozdílu.
     *
     * @return Vrací 2d pole jako rozdíl dvou matic. Pokud nejsou operandy
     * stejného rozměru, vrací se 2d pole o rozměru double [0][0].
     */
    public static double[][] odecti(double[][] m1, double[][] m2) {
        if (m1.length != m2.length || m1[0].length != m2[0].length) {
            return new double[0][0];
        } else {

            double odecti[][] = new double[m1.length][m1[0].length];

            for (int i = 0; i < m1.length; i++) {
                for (int j = 0; j < m1[0].length; j++) {
                    odecti[i][j] = m1[i][j] - m2[i][j];
                }
            }

            return odecti;
        }

    }

    /**
     * Metoda vynásobí hodnotou v parametru všechny hodnoty dvojrozměrného pole.
     *
     *
     * Popis činnosti metody:
     * <ol>
     * <li>Metoda vytvoří nové pole o shodných rozměrech se vstupním polem.</li>
     *
     * <li>Do každého prvku nového 2d pole metoda vloží stejnolehlý prvek
     * vstupního pole, který bude vynásoben konstantou k.</li>
     * </ol>
     *
     * @param m1 Vstupní 2d pole
     * @param k Konstanta na vynásobení prvků matice
     * @return Nové 2d pole s vynásobeným obsahem
     */
    public static double[][] vynasobCislem(double[][] m1, double k) {

        double nasobeni[][] = new double[m1.length][m1[0].length];

        for (int i = 0; i < m1.length; i++) {
            for (int j = 0; j < m1[0].length; j++) {
                nasobeni[i][j] = m1[i][j] * k;
            }
        }

        return nasobeni;
    }

    /**
     * Metoda vydělí hodnotou v parametru všechny hodnoty dvojrozměrného pole.
     *
     *
     * Popis činnosti metody:
     * <ol>
     * <li>Metoda vytvoří nové pole o shodných rozměrech se vstupním polem.</li>
     *
     * <li>Do každého prvku nového pole metoda vloží stejnolehlý prvek vstupního
     * pole, který bude vydělen konstantou k.</li>
     * </ol>
     *
     * @param m1 Vstupní 2d pole
     * @param k Konstanta na vynásobení prvků matice
     * @return Nové 2D pole s vyděleným obsahem
     */
    public static double[][] vydelCislem(double[][] m1, double k) {

        double deleni[][] = new double[m1.length][m1[0].length];

        for (int i = 0; i < m1.length; i++) {
            for (int j = 0; j < m1[0].length; j++) {
                deleni[i][j] = m1[i][j] / k;
            }
        }

        return deleni;
    }

    /**
     * Metoda přičte jednorozměrné pole k řádku dvojrozměrného pole.
     *
     * Popis činnosti metody:
     * <ol>
     * <li>Metoda nejříve zkontroluje rozměry 2d a 1d vstupních polí, zda
     * vyhovují operaci pričtení řádku.</li>
     *
     * <li>Metoda vytvoří nové 2d pole o shodných rozměrech se vstupním 2d
     * polem.</li>
     *
     * <li>Do nového 2d pole metoda zkopíruje vstupní pole m1. </li>
     *
     * <li>Do nového 2d pole metoda k řádku daného indexem v parametru radek
     * přičte stejnolehlé hodnoty z jednorozměrného pole.</li>
     *
     * <li>Referenci na nové 2d pole metda předá v návratové hodnotě.</li>
     * </ol>
     *
     * @param m1 Vstupní 2d pole
     * @param pole Jednorozměrné pole
     * @param radek Index řádku ke kterému se přičte pole
     *
     * @return Nové 2D pole s přičteným řádkem
     */
    public static double[][] prictiRadek(double[][] m1, double[] pole, int radek) {

        if (m1[0].length == pole.length) {

            for (int i = 0; i < m1[0].length; i++) {
                m1[radek][i] = m1[radek][i] + pole[i];
            }
            return m1;
        } else {
            return new double[0][0];
        }

    }

    /**
     * Metoda odečte jednorozměrné pole od řádku dvojrozměrného pole.
     *
     *
     * Popis činnosti metody:
     * <ol>
     * <li>Metoda nejříve zkontroluje rozměry 2d a 1d polí, zda vyhovují operaci
     * odečtení řádku.</li>
     *
     * <li>Metoda vytvoří nové 2d pole o shodných rozměrech se vstupním 2d
     * polem.</li>
     *
     * <li>Do nového 2d pole metoda zkopíruje vstupní pole m1. </li>
     *
     * <li>Do nového 2d pole metoda k řádku daného indexem v parametru radek
     * odečte stejnolehlé hodnoty z jednorozměrného pole.</li>
     *
     * <li>Reference na nové 2d pole se předá v návratové hodnotě metody.</li>
     * </ol>
     *
     * @param m1 Vstupní 2d pole
     * @param pole Vstupní 1d pole
     * @param radek Index řádku od kterého se odečte 1d pole
     *
     * @return Nové 2d pole s odečteným řádkem
     */
    public static double[][] odectiRadek(double[][] m1, double[] pole, int radek) {
        if (m1[0].length == pole.length) {

            for (int i = 0; i < m1[0].length; i++) {
                m1[radek][i] = m1[radek][i] - pole[i];
            }
            return m1;
        } else {
            return new double[0][0];
        }
    }

    /**
     * Metoda přičte k vybranému sloupci 2d pole 1d pole.
     *
     * Popis činnosti metody:
     * <ol>
     * <li>Metoda nejříve zkontroluje rozměry 2d a 1d polí, zda vyhovují operaci
     * přičtení sloupce.</li>
     *
     * <li>Metoda vytvoří nové 2d pole o shodných rozměrech se vstupním 2d
     * polem.</li>
     *
     * <li>Do nového 2d pole metoda zkopíruje vstupní pole m1. </li>
     *
     * <li>Do nového 2d pole metoda k sloupci daného indexem v parametru sloupec
     * přičte stejnolehlé hodnoty z jednorozměrného pole.</li>
     *
     * <li>Reference na nové 2d pole metoda předá v návratové hodnotě.</li>
     * </ol>
     *
     * @param m1 Vstupmí 2d pole
     * @param pole Vstupní 1d pole
     * @param sloupec Index sloupce ke kterému se bude přičítat 1d
     *
     * @return Nové 2D pole s přičteným sloupcem
     */
    public static double[][] prictiSloupec(double[][] m1, double[] pole, int sloupec) {
        if (m1.length == pole.length) {
            for (int i = 0; i < m1.length; i++) {
                m1[i][sloupec] = m1[i][sloupec]+pole[i];
            }
            return m1;
        } else {
            return new double[0][0];
        }

    }

    /**
     * Metoda odečte od vybraného sloupce 2d pole 1d pole.
     *
     * Popis činnosti metody:
     * <ol>
     * <li>Metoda nejříve zkontroluje rozměry 2d a 1d polí, zda vyhovují operaci
     * odečtení sloupce.</li>
     *
     * <li>Metoda vytvoří nové 2d pole o shodných rozměrech se vstupním 2d
     * polem.</li>
     *
     * <li>Do nového 2d pole metoda zkopíruje vstupní pole m1. </li>
     *
     * <li>Do nového 2d pole metoda k sloupci daného indexem v parametru sloupec
     * odečte stejnolehlé hodnoty z jednorozměrného pole.</li>
     *
     * <li>Reference na nové 2d pole metoda předá v návratové hodnotě.</li>
     * </ol>
     *
     * @param m1 Vstupmí 2d pole
     * @param pole Vstupní 1d pole
     * @param sloupec Index sloupce ke kterému se bude přičítat 1d
     *
     * @return Nové 2D pole s odečteným sloupcem
     */
    public static double[][] odectiSloupec(double[][] m1, double[] pole, int sloupec) {
        if (m1.length == pole.length) {
            for (int i = 0; i < m1.length; i++) {
                m1[i][sloupec] = m1[i][sloupec]-pole[i];
            }
            return m1;
        } else {
            return new double[0][0];
        }
    }
}