package cz.frantovo.příklady.reflexe;

 import java.lang.reflect.Field;

 import java.math.BigDecimal;

 import java.math.RoundingMode;

 import java.util.Map;

 import java.util.Objects;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.function.Consumer;

 /**

  *

  * @author Ing. František Kučera (frantovo.cz)

  */

 public class Reflexe {

 	private static final String NÁZEV_PROMĚNNÉ = "proměnná";

 	private static final int POČET_OPAKOVÁNÍ = 1000000;

 	private static final RoundingMode ZAOKROUHLOVÁNÍ = RoundingMode.UP;

 	private static final int PŘESNOST_PROCENT = 2;

 	private static final Map<KlíčTřídaPole, Field> známáPole = new ConcurrentHashMap<>();

 	private static final Map<Class, Map<String, Field>> známáPole2 = new ConcurrentHashMap<>();

 	private static void nastav(Object objekt, String proměnná, Object hodnota) throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {

 		Field f = objekt.getClass().getDeclaredField(proměnná);

 		f.setAccessible(true);

 		f.set(objekt, hodnota);

 		// TODO: můžeme odchytávat výjimky a vyhazovat vlastní výjimku případně běhovou

 	}

 	private static void nastavOptimalizovaně(Object objekt, String proměnná, Object hodnota) throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {

 		KlíčTřídaPole klíč = new KlíčTřídaPole(objekt.getClass(), proměnná);

 		Field f = známáPole.get(klíč);

 		if (f == null) {

 			f = objekt.getClass().getDeclaredField(proměnná);

 			f.setAccessible(true);

 			známáPole.put(klíč, f);

 		}

 		f.set(objekt, hodnota);

 		// TODO: můžeme odchytávat výjimky a vyhazovat vlastní výjimku případně běhovou

 	}

 	private static class KlíčTřídaPole {

 		private final Class třída;

 		private final String pole;

 		public KlíčTřídaPole(Class třída, String pole) {

 			this.třída = třída;

 			this.pole = pole;

 		}

 		@Override

 		public boolean equals(Object obj) {

 			if (obj instanceof KlíčTřídaPole) {

 				KlíčTřídaPole druhýKlíč = (KlíčTřídaPole) obj;

 				return Objects.equals(třída, druhýKlíč.třída) && Objects.equals(pole, druhýKlíč.pole);

 			} else {

 				return false;

 			}

 		}

 		@Override

 		public int hashCode() {

 			return Objects.hash(třída, pole);

 		}

 	}

 	private static void nastavOptimalizovaně2(Object objekt, String proměnná, Object hodnota) throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {

 		Map<String, Field> mapaPolí = známáPole2.get(objekt.getClass());

 		if (mapaPolí == null) {

 			mapaPolí = new ConcurrentHashMap<>();

 			známáPole2.put(objekt.getClass(), mapaPolí);

 		}

 		Field f = mapaPolí.get(proměnná);

 		if (f == null) {

 			f = objekt.getClass().getDeclaredField(proměnná);

 			f.setAccessible(true);

 			mapaPolí.put(proměnná, f);

 		}

 		f.set(objekt, hodnota);

 		// TODO: můžeme odchytávat výjimky a vyhazovat vlastní výjimku případně běhovou

 	}

 	private static void testSetter(int početOpakování) {

 		NějakáTřída t = new NějakáTřída();

 		for (int i = 0; i < početOpakování; i++) {

 			t.setProměnná(i);

 		}

 	}

 	private static void testPřímýPřístup(int početOpakování) {

 		NějakáTřída t = new NějakáTřída();

 		for (int i = 0; i < početOpakování; i++) {

 			t.veřejnáProměnná = i;

 		}

 	}

 	private static void testReflexe(int početOpakování) {

 		NějakáTřída t = new NějakáTřída();

 		try {

 			for (int i = 0; i < početOpakování; i++) {

 				nastav(t, NÁZEV_PROMĚNNÉ, i);

 			}

 		} catch (Exception e) {

 			throw new RuntimeException("test se nezdařil", e);

 		}

 	}

 	private static void testReflexeOptimalizovaná(int početOpakování) {

 		NějakáTřída t = new NějakáTřída();

 		try {

 			for (int i = 0; i < početOpakování; i++) {

 				nastavOptimalizovaně(t, NÁZEV_PROMĚNNÉ, i);

 			}

 		} catch (Exception e) {

 			throw new RuntimeException("test se nezdařil", e);

 		}

 	}

 	private static void testReflexeOptimalizovaná2(int početOpakování) {

 		NějakáTřída t = new NějakáTřída();

 		try {

 			for (int i = 0; i < početOpakování; i++) {

 				nastavOptimalizovaně2(t, NÁZEV_PROMĚNNÉ, i);

 			}

 		} catch (Exception e) {

 			throw new RuntimeException("test se nezdařil", e);

 		}

 	}

 	private static void testReflexePřipravená(int početOpakování) {

 		NějakáTřída t = new NějakáTřída();

 		try {

 			Field f = t.getClass().getDeclaredField(NÁZEV_PROMĚNNÉ);

 			f.setAccessible(true);

 			for (int i = 0; i < početOpakování; i++) {

 				f.set(t, i);

 			}

 		} catch (Exception e) {

 			throw new RuntimeException("test se nezdařil", e);

 		}

 	}

 	private static String lpad(int početZnaků, Object text) {

 		return String.format("%1$" + početZnaků + "s", String.valueOf(text));

 	}

 	private static BigDecimal spočítejProcenta(long hodnota, long základ) {

 		BigDecimal h = BigDecimal.valueOf(hodnota);

 		BigDecimal z = BigDecimal.valueOf(základ);

 		return h.multiply(BigDecimal.valueOf(100)).divide(z, PŘESNOST_PROCENT, ZAOKROUHLOVÁNÍ);

 	}

 	private static Long testuj(String názevTestu, int početOpakování, Long časProPorovnání, Consumer<Integer> test) {

 		System.out.print("TEST: " + lpad(24, názevTestu) + ": ");

 		try {

 			long začátek = System.currentTimeMillis();

 			test.accept(početOpakování);

 			long konec = System.currentTimeMillis();

 			long celkovýČas = konec - začátek;

 			BigDecimal relativníČas = časProPorovnání == null ? BigDecimal.valueOf(100).setScale(PŘESNOST_PROCENT) : spočítejProcenta(celkovýČas, časProPorovnání);

 			System.out.println("početOpakování = " + lpad(12, početOpakování) + " celkovýČas = " + lpad(8, celkovýČas) + " ms relativníČas = " + lpad(8, relativníČas) + " %");

 			return celkovýČas;

 		} catch (Exception e) {

 			System.out.println("došlo k chybě");

 			e.printStackTrace();

 			return null;

 		}

 	}

 	public static void main(String[] args) {

 		long základníČas = testuj("přímý přístup", POČET_OPAKOVÁNÍ, null, Reflexe::testPřímýPřístup);

 		testuj("setter", POČET_OPAKOVÁNÍ, základníČas, Reflexe::testSetter);

 		testuj("reflexe", POČET_OPAKOVÁNÍ, základníČas, Reflexe::testReflexe);

 		testuj("reflexe optimalizovaná 1", POČET_OPAKOVÁNÍ, základníČas, Reflexe::testReflexeOptimalizovaná);

 		testuj("reflexe optimalizovaná 2", POČET_OPAKOVÁNÍ, základníČas, Reflexe::testReflexeOptimalizovaná2);

 		testuj("reflexe připravená", POČET_OPAKOVÁNÍ, základníČas, Reflexe::testReflexePřipravená);

 	}

 }